1 2 /* HOW TO COMPILE: 3 4 gcc -O -g -Wall -maltivec -mabi=altivec -DALTIVEC -DGCC_COMPILER 5 testVMX.c -o testVMX 6 7 */ 8 9 /* 10 * testVMX - A test program to check the correctness of VMX instructions 11 * 12 * Copyright (C) 2004 CEPBA-IBM Research Institute 13 * 14 * Authors: Jose Maria Cela, Raul de la Cruz, 15 * Rogeli Grima, Xavier Saez <blade_support (at) ciri.upc.es> 16 * 17 * Web page: http://www.ciri.upc.es/cela_pblade/ 18 * 19 * This file is part of testVMX. 20 * 21 * testVMX is free software; you can redistribute it and/or modify 22 * it under the terms of the GNU General Public License as published by 23 * the Free Software Foundation; either version 2 of the License, or 24 * (at your option) any later version. 25 * 26 * testVMX is distributed in the hope that it will be useful, 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of 28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 29 * GNU General Public License for more details. 30 * 31 * You should have received a copy of the GNU General Public License 32 * along with testVMX; if not, write to the Free Software 33 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 US 34 */ 35 36 /* 37 * Version 0.2.2 2004/09/02 38 * Removed some not useful flags for compilation and changed the GPL license 39 * header updating the contact email and adding the web page URL 40 * 41 * Version 0.2.1 2004/07/07 42 * Some flags added in Makefile for XLC compilation (-qalias, -qinline) 43 * 44 * Version 0.2 2004/07/02 45 * Makefile and testVMX.c patched to compile with SLES 9 (Linux - GCC 3.3.3), 46 * IBM XLC Enterprise Edition and MacOS X 10.3 (Darwin - GCC 3.3) 47 * 48 * Version 0.1 2004/03/05 49 * First public version release 50 */ 51 52 53 #include <stdio.h> 54 #include <stdlib.h> 55 #include <math.h> 56 #include <limits.h> 57 #include <string.h> 58 59 /* Calloc for align data to 16 bytes boundaries */ 60 61 /* ----------- BEGIN #include "memoryVector.h" ----------- */ 62 63 /* 64 * testVMX - A test program to check the correctness of VMX instructions 65 * 66 * Copyright (C) 2004 CEPBA-IBM Research Institute 67 * 68 * Authors: Jose Maria Cela, Raul de la Cruz, 69 * Rogeli Grima, Xavier Saez <blade_support (at) ciri.upc.es> 70 * 71 * Web page: http://www.ciri.upc.es/cela_pblade/ 72 * 73 * This file is part of testVMX. 74 * 75 * testVMX is free software; you can redistribute it and/or modify 76 * it under the terms of the GNU General Public License as published by 77 * the Free Software Foundation; either version 2 of the License, or 78 * (at your option) any later version. 79 * 80 * testVMX is distributed in the hope that it will be useful, 81 * but WITHOUT ANY WARRANTY; without even the implied warranty of 82 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 83 * GNU General Public License for more details. 84 * 85 * You should have received a copy of the GNU General Public License 86 * along with testVMX; if not, write to the Free Software 87 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 US 88 */ 89 90 #ifndef MEMORY_VECTOR_H 91 # define MEMORY_VECTOR_H 92 93 # include <stdlib.h> 94 95 void *calloc_vec( size_t nmemb, size_t size ); 96 void free_vec( void *ptr ); 97 98 #endif 99 100 /* ----------- END #include "memoryVector.h" ----------- */ 101 102 /* ----------- BEGIN #include "memoryVector.c" ----------- */ 103 104 /* 105 * testVMX - A test program to check the correctness of VMX instructions 106 * 107 * Copyright (C) 2004 CEPBA-IBM Research Institute 108 * 109 * Authors: Jose Maria Cela, Raul de la Cruz, 110 * Rogeli Grima, Xavier Saez <blade_support (at) ciri.upc.es> 111 * 112 * Web page: http://www.ciri.upc.es/cela_pblade/ 113 * 114 * This file is part of testVMX. 115 * 116 * testVMX is free software; you can redistribute it and/or modify 117 * it under the terms of the GNU General Public License as published by 118 * the Free Software Foundation; either version 2 of the License, or 119 * (at your option) any later version. 120 * 121 * testVMX is distributed in the hope that it will be useful, 122 * but WITHOUT ANY WARRANTY; without even the implied warranty of 123 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 124 * GNU General Public License for more details. 125 * 126 * You should have received a copy of the GNU General Public License 127 * along with testVMX; if not, write to the Free Software 128 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 US 129 */ 130 131 #include <stdio.h> 132 #include <string.h> 133 /* #include "memoryVector.h"*/ 134 135 typedef struct 136 { 137 char *realAdd; 138 char *returnAdd; 139 } Tmemtab; 140 141 142 static Tmemtab *memTab = NULL; 143 static size_t nadd = 0; 144 static size_t MAX_N_ADD = 100; 145 146 147 void *calloc_vec( size_t nmemb, size_t size ) 148 { 149 /* ---------------------------------------------------------- Local Variables */ 150 char *realadd; 151 char *retadd; 152 size_t nbytes, cc, rr; 153 154 /* -------------------------------------------------------------------- BEGIN */ 155 if (memTab == (Tmemtab*)NULL) 156 { 157 memTab = (Tmemtab *) malloc( MAX_N_ADD*sizeof(Tmemtab) ); 158 if (memTab == (Tmemtab*)NULL) 159 { 160 fprintf(stderr, "\n------------ FATAL ERRROR ------------------\n"); 161 fprintf(stderr, "Memory table out of memory\n"); 162 return NULL; 163 } 164 } 165 166 /* 16 extra bytes are allocated for adjust alignement */ 167 nbytes = (size*nmemb)+16; 168 169 /* Alloc a block of 'nbytes' */ 170 realadd = (char *) malloc( nbytes ); 171 if (realadd == (char *)NULL) 172 { 173 fprintf(stderr, "\n------------ FATAL ERRROR ------------------\n"); 174 fprintf(stderr, "Out of memory\n"); 175 return NULL; 176 } 177 178 memset( realadd, 0, nbytes ); 179 180 cc = ((size_t)realadd)/16; 181 rr = ((size_t)realadd)%16; 182 if (rr == 0) 183 retadd = realadd; 184 else 185 retadd = (char *)((cc+1)*16); 186 187 if (nadd == MAX_N_ADD) 188 { 189 MAX_N_ADD += 100; 190 memTab = (Tmemtab*) realloc( memTab, MAX_N_ADD*sizeof(Tmemtab) ); 191 if (memTab == (Tmemtab*)NULL) 192 { 193 free( realadd ); 194 fprintf(stderr, "\n------------ FATAL ERRROR ------------------\n"); 195 fprintf(stderr, "Memory table out of memory\n"); 196 return NULL; 197 } 198 } 199 200 memTab[nadd].realAdd = realadd; 201 memTab[nadd].returnAdd = retadd;; 202 nadd++; 203 204 return (void*)retadd; 205 /* ---------------------------------------------------------------------- END */ 206 } 207 208 209 void free_vec( void *ptr ) 210 { 211 /* ---------------------------------------------------------- Local Variables */ 212 int ii, pos; 213 214 /* -------------------------------------------------------------------- BEGIN */ 215 pos = -1; 216 for (ii= 0; ii< nadd; ii++) 217 if (memTab[ii].returnAdd == ptr) 218 { 219 pos = ii; 220 break; 221 } 222 223 if (pos == -1) 224 { 225 fprintf(stderr, "\n------------ WARNING ------------------------\n"); 226 fprintf(stderr, "Pointer not found in memory table\n\n"); 227 } 228 else 229 { 230 free( memTab[ii].realAdd ); 231 232 for (ii= pos+1; ii< nadd; ii++) 233 memTab[ii-1] = memTab[ii]; 234 nadd--; 235 236 if (nadd == 0) 237 { 238 free( memTab ); 239 memTab = NULL; 240 MAX_N_ADD = 100; 241 } 242 } 243 /* ---------------------------------------------------------------------- END */ 244 } 245 246 247 /* ----------- END #include "memoryVector.c" ----------- */ 248 249 250 #ifdef ALTIVEC 251 # ifdef GCC_COMPILER 252 # include <altivec.h> 253 # endif 254 255 256 257 //#define TEST_FLOATS 258 259 260 261 /* Redefinition for undefined NAN and xlC compiling C++ code */ 262 # if !defined(NAN) || ( defined(__IBMCPP__) && defined(XLC_COMPILER) ) 263 # undef NAN 264 # define NAN 0x7FC00000 265 /* # define NAN 0xFFFA5A5A 266 * # define NAN 0x80000000 267 * # define NAN 0x00008000 268 */ 269 # endif 270 271 272 int part1( ); 273 int part2( ); 274 int part3( ); 275 int part4( ); 276 int part5( ); 277 278 279 typedef union 280 { 281 vector signed char v; 282 signed char e[16]; 283 } TvecChar; 284 285 typedef union 286 { 287 vector unsigned char v; 288 unsigned char e[16]; 289 } TvecUChar; 290 291 typedef union 292 { 293 vector bool char v; 294 unsigned char e[16]; 295 } TvecBChar; 296 297 typedef union 298 { 299 vector signed short v; 300 signed short e[8]; 301 } TvecShort; 302 303 typedef union 304 { 305 vector unsigned short v; 306 unsigned short e[8]; 307 } TvecUShort; 308 309 typedef union 310 { 311 vector bool short v; 312 unsigned short e[8]; 313 } TvecBShort; 314 315 typedef union 316 { 317 vector signed int v; 318 signed int e[4]; 319 } TvecInt; 320 321 typedef union 322 { 323 vector unsigned int v; 324 unsigned int e[4]; 325 } TvecUInt; 326 327 typedef union 328 { 329 vector bool int v; 330 unsigned int e[4]; 331 } TvecBInt; 332 333 #if defined TEST_FLOATS 334 typedef union 335 { 336 vector float v; 337 float e[4]; 338 signed int i[4]; 339 } TvecFloat; 340 #endif 341 342 /* Scalar bool types declaration */ 343 typedef unsigned char TboolChar; 344 typedef unsigned short TboolShort; 345 typedef unsigned int TboolInt; 346 347 #endif 348 349 350 351 352 353 354 /********************************************************************** 355 Main() 356 **********************************************************************/ 357 358 359 360 int main() 361 { 362 TvecChar Caux1, Caux2, Caux3;//, Caux4; 363 TvecUChar UCaux1, UCaux2, UCaux3;//, UCaux4; 364 TvecBChar BCaux1;//, BCaux2, BCaux3, BCaux4; 365 TvecShort Saux1, Saux2, Saux3;//, Saux4; 366 TvecUShort USaux1, USaux2, USaux3;//, USaux4; 367 TvecBShort BSaux1;//, BSaux2, BSaux3, BSaux4; 368 TvecInt Iaux1, Iaux2, Iaux3;//, Iaux4; 369 TvecUInt UIaux1, UIaux2, UIaux3;//, UIaux4; 370 TvecBInt BIaux1;//, BIaux2, BIaux3, BIaux4; 371 #if defined TEST_FLOATS 372 TvecFloat Faux1, Faux2, Faux3;//, Faux4; 373 #endif 374 375 int i, err, j;//, b, bAux; 376 #if defined TEST_FLOATS 377 int b; 378 signed int Ivec1, Ivec2, Ivec3; 379 #endif 380 381 // unsigned char *UCvec1; 382 // signed short *Svec1; 383 // unsigned short *USvec1; 384 // unsigned int *UIvec1; 385 #if defined TEST_FLOATS 386 // float *Fvec1; 387 #endif 388 389 /* For saturated rutines */ 390 // long long int LLaux; 391 392 signed char Caux; 393 unsigned char UCaux; 394 signed short Saux; 395 unsigned short USaux; 396 signed int Iaux;//, I1, I2; 397 unsigned int UIaux;//, UI1, UI2; 398 #if defined TEST_FLOATS 399 float Faux; 400 #endif 401 402 /* Scalar bool types definition */ 403 TboolChar BCaux; 404 TboolShort BSaux; 405 TboolInt BIaux; 406 407 /* 408 union 409 { 410 float f; 411 signed int si; 412 unsigned int ui; 413 signed short ss[2]; 414 unsigned short us[2]; 415 signed char sc[4]; 416 unsigned char uc[4]; 417 } INTunion1, INTunion2; 418 419 union 420 { 421 signed short ss; 422 unsigned short us; 423 signed char sc[2]; 424 unsigned char uc[2]; 425 } SHOunion1, SHOunion2; 426 */ 427 428 #if defined (GCC_COMPILER) 429 vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 430 vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 431 vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127}; 432 vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7}; 433 vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; 434 vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}; 435 vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3}; 436 vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000}; 437 vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767}; 438 vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3}; 439 vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1}; 440 vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4}; 441 vector signed int Icons1 = (vector signed int){-4, -1, 1, 4}; 442 vector signed int Icons2 = (vector signed int){1, 1, 1, 1}; 443 vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF}; 444 vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1}; 445 vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1}; 446 vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2}; 447 448 #if defined TEST_FLOATS 449 vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999}; 450 vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0}; 451 vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0}; 452 #endif 453 454 #elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 455 vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 456 vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); 457 vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127); 458 vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7); 459 vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2); 460 vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8); 461 vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3); 462 vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000); 463 vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767); 464 vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3); 465 vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1); 466 vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4); 467 vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4); 468 vector signed int Icons2 = (vector signed int)(1, 1, 1, 1); 469 vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF); 470 vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1); 471 vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1); 472 vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2); 473 474 #if defined TEST_FLOATS 475 vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999); 476 vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0); 477 vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0); 478 #endif 479 480 #endif 481 482 483 /* Function vec_abs */ 484 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 485 err = 0; 486 Caux1.v = vec_abs( Ccons1 ); 487 Caux2.v = Ccons1; 488 for( i=0; i< 16; i++ ) 489 if (Caux1.e[i] != abs( Caux2.e[i] )) 490 err++; 491 if (err) 492 printf("Function vec_abs [type char] ===> Error\n"); 493 else 494 printf("Function vec_abs [type char] ===> OK\n"); 495 496 err = 0; 497 Saux1.v = vec_abs( Scons1 ); 498 Saux2.v = Scons1; 499 for( i=0; i< 8; i++ ) 500 if (Saux1.e[i] != abs( Saux2.e[i] )) 501 err++; 502 if (err) 503 printf("Function vec_abs [type short] ===> Error\n"); 504 else 505 printf("Function vec_abs [type short] ===> OK\n"); 506 507 err = 0; 508 Iaux1.v = vec_abs( Icons1 ); 509 Iaux2.v = Icons1; 510 for( i=0; i< 4; i++ ) 511 if (Iaux1.e[i] != abs( Iaux2.e[i] )) 512 err++; 513 if (err) 514 printf("Function vec_abs [type integer] ===> Error\n"); 515 else 516 printf("Function vec_abs [type integer] ===> OK\n"); 517 518 #if defined TEST_FLOATS 519 err = 0; 520 Faux1.v = vec_abs( Fcons1 ); 521 Faux2.v = Fcons1; 522 for( i=0; i< 4; i++ ) 523 if (Faux1.e[i] != fabs( Faux2.e[i] )) 524 err++; 525 if (err) 526 printf("Function vec_abs [type float] ===> Error\n"); 527 else 528 printf("Function vec_abs [type float] ===> OK\n"); 529 #endif 530 531 /* Function vec_abss */ 532 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 533 err = 0; 534 Caux1.v = vec_abss( Ccons1 ); 535 Caux2.v = Ccons1; 536 for( i=0; i< 16; i++ ) 537 if (Caux1.e[i] != abs( Caux2.e[i] )) 538 err++; 539 if (err) 540 printf("Function vec_abss [type char] ===> Error\n"); 541 else 542 printf("Function vec_abss [type char] ===> OK\n"); 543 544 err = 0; 545 Saux1.v = vec_abss( Scons1 ); 546 Saux2.v = Scons1; 547 for( i=0; i< 8; i++ ) 548 if (Saux1.e[i] != abs( Saux2.e[i] )) 549 err++; 550 if (err) 551 printf("Function vec_abss [type short] ===> Error\n"); 552 else 553 printf("Function vec_abss [type short] ===> OK\n"); 554 555 err = 0; 556 Iaux1.v = vec_abss( Icons1 ); 557 Iaux2.v = Icons1; 558 for( i=0; i< 4; i++ ) 559 if (Iaux1.e[i] != abs( Iaux2.e[i] )) 560 err++; 561 if (err) 562 printf("Function vec_abss [type integer] ===> Error\n"); 563 else 564 printf("Function vec_abss [type integer] ===> OK\n"); 565 566 /* Function vec_add */ 567 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 568 err = 0; 569 Caux1.v = vec_add( Ccons1, Ccons2 ); 570 Caux2.v = Ccons1; 571 Caux3.v = Ccons2; 572 for( i=0; i< 16; i++ ) 573 { 574 Caux = Caux2.e[i]+Caux3.e[i]; 575 if (Caux1.e[i] != Caux) 576 err++; 577 } 578 if (err) 579 printf("Function vec_add [type char] ===> Error\n"); 580 else 581 printf("Function vec_add [type char] ===> OK\n"); 582 583 err = 0; 584 UCaux1.v = vec_add( UCcons1, UCcons2 ); 585 UCaux2.v = UCcons1; 586 UCaux3.v = UCcons2; 587 for( i=0; i< 16; i++ ) 588 { 589 UCaux = UCaux2.e[i]+UCaux3.e[i]; 590 if (UCaux1.e[i] != UCaux) 591 err++; 592 } 593 if (err) 594 printf("Function vec_add [type unsigned char] ===> Error\n"); 595 else 596 printf("Function vec_add [type unsigned char] ===> OK\n"); 597 598 err = 0; 599 Saux1.v = vec_add( Scons1, Scons2 ); 600 Saux2.v = Scons1; 601 Saux3.v = Scons2; 602 for( i=0; i< 8; i++ ) 603 { 604 Saux = Saux2.e[i]+Saux3.e[i]; 605 if (Saux1.e[i] != Saux) 606 err++; 607 } 608 if (err) 609 printf("Function vec_add [type short] ===> Error\n"); 610 else 611 printf("Function vec_add [type short] ===> OK\n"); 612 613 err = 0; 614 USaux1.v = vec_add( UScons1, UScons2 ); 615 USaux2.v = UScons1; 616 USaux3.v = UScons2; 617 for( i=0; i< 8; i++ ) 618 { 619 USaux = USaux2.e[i]+USaux3.e[i]; 620 if (USaux1.e[i] != USaux) 621 err++; 622 } 623 if (err) 624 printf("Function vec_add [type unsigned short] ===> Error\n"); 625 else 626 printf("Function vec_add [type unsigned short] ===> OK\n"); 627 628 err = 0; 629 Iaux1.v = vec_add( Icons1, Icons2 ); 630 Iaux2.v = Icons1; 631 Iaux3.v = Icons2; 632 for( i=0; i< 4; i++ ) 633 { 634 Iaux = Iaux2.e[i]+Iaux3.e[i]; 635 if (Iaux1.e[i] != Iaux) 636 err++; 637 } 638 if (err) 639 printf("Function vec_add [type integer] ===> Error\n"); 640 else 641 printf("Function vec_add [type integer] ===> OK\n"); 642 643 err = 0; 644 UIaux1.v = vec_add( UIcons1, UIcons3 ); 645 UIaux2.v = UIcons1; 646 UIaux3.v = UIcons3; 647 for( i=0; i< 4; i++ ) 648 { 649 UIaux = UIaux2.e[i]+UIaux3.e[i]; 650 if (UIaux1.e[i] != UIaux) 651 err++; 652 } 653 if (err) 654 printf("Function vec_add [type unsigned int] ===> Error\n"); 655 else 656 printf("Function vec_add [type unsigned int] ===> OK\n"); 657 658 #if defined TEST_FLOATS 659 err = 0; 660 Faux1.v = vec_add( Fcons1, Fcons2 ); 661 Faux2.v = Fcons1; 662 Faux3.v = Fcons2; 663 for( i=0; i< 4; i++ ) 664 { 665 Faux = Faux2.e[i]+Faux3.e[i]; 666 if (Faux1.e[i] != Faux) 667 err++; 668 } 669 if (err) 670 printf("Function vec_add [type float] ===> Error\n"); 671 else 672 printf("Function vec_add [type float] ===> OK\n"); 673 #endif 674 675 676 /* Function vec_addc */ 677 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 678 err = 0; 679 UIaux1.v = vec_addc( UIcons1, UIcons3 ); 680 UIaux2.v = UIcons1; 681 UIaux3.v = UIcons3; 682 for( i=0; i< 4; i++ ) 683 { 684 UIaux = (unsigned int)(UIaux2.e[i]+UIaux3.e[i]); 685 if ((UIaux< UIaux2.e[i]) || (UIaux< UIaux3.e[i])) 686 UIaux=1; 687 else 688 UIaux=0; 689 if (UIaux1.e[i] != UIaux) 690 err++; 691 } 692 if (err) 693 printf("Function vec_addc [type unsigned int] ===> Error\n"); 694 else 695 printf("Function vec_addc [type unsigned int] ===> OK\n"); 696 697 /* Function vec_adds */ 698 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 699 err = 0; 700 Caux1.v = vec_adds( Ccons1, Ccons3 ); 701 Caux2.v = Ccons1; 702 Caux3.v = Ccons3; 703 for( i=0; i< 16; i++ ) 704 { 705 Caux = Caux2.e[i]+Caux3.e[i]; 706 if ((Caux2.e[i]>0)&&(Caux3.e[i]>0)) 707 { 708 if (Caux< 0) 709 Caux=0x7F; 710 } 711 else if ((Caux2.e[i]<0)&&(Caux3.e[i]<0)) 712 { 713 if (Caux> 0) 714 Caux=0x80; 715 } 716 if (Caux1.e[i] != Caux) 717 err++; 718 } 719 if (err) 720 printf("Function vec_adds [type char] ===> Error\n"); 721 else 722 printf("Function vec_adds [type char] ===> OK\n"); 723 724 err = 0; 725 UCaux1.v = vec_adds( UCcons1, UCcons3 ); 726 UCaux2.v = UCcons1; 727 UCaux3.v = UCcons3; 728 for( i=0; i< 16; i++ ) 729 { 730 UCaux = (unsigned char)(UCaux2.e[i]+UCaux3.e[i]); 731 if ((UCaux< UCaux2.e[i]) || (UCaux< UCaux3.e[i])) 732 UCaux=0xFF; 733 if (UCaux1.e[i] != UCaux) 734 err++; 735 } 736 if (err) 737 printf("Function vec_adds [type unsigned char] ===> Error\n"); 738 else 739 printf("Function vec_adds [type unsigned char] ===> OK\n"); 740 741 err = 0; 742 Saux1.v = vec_adds( Scons1, Scons3 ); 743 Saux2.v = Scons1; 744 Saux3.v = Scons3; 745 for( i=0; i< 8; i++ ) 746 { 747 Saux = Saux2.e[i]+Saux3.e[i]; 748 if ((Saux2.e[i]>0)&&(Saux3.e[i]>0)) 749 { 750 if (Saux< 0) 751 Saux=0x7FFF; 752 } 753 else if ((Saux2.e[i]<0)&&(Saux3.e[i]<0)) 754 { 755 if (Saux> 0) 756 Saux=0x8000; 757 } 758 if (Saux1.e[i] != Saux) 759 err++; 760 } 761 if (err) 762 printf("Function vec_adds [type short] ===> Error\n"); 763 else 764 printf("Function vec_adds [type short] ===> OK\n"); 765 766 err = 0; 767 USaux1.v = vec_adds( UScons1, UScons3 ); 768 USaux2.v = UScons1; 769 USaux3.v = UScons3; 770 for( i=0; i< 8; i++ ) 771 { 772 USaux = (unsigned short)(USaux2.e[i]+USaux3.e[i]); 773 if ((USaux< USaux2.e[i]) || (USaux< USaux3.e[i])) 774 USaux=0xFFFF; 775 if (USaux1.e[i] != USaux) 776 err++; 777 } 778 if (err) 779 printf("Function vec_adds [type unsigned short] ===> Error\n"); 780 else 781 printf("Function vec_adds [type unsigned short] ===> OK\n"); 782 783 784 err = 0; 785 Iaux1.v = vec_adds( Icons1, Icons3 ); 786 Iaux2.v = Icons1; 787 Iaux3.v = Icons3; 788 for( i=0; i< 4; i++ ) 789 { 790 Iaux = Iaux2.e[i]+Iaux3.e[i]; 791 if ((Iaux2.e[i]>0)&&(Iaux3.e[i]>0)) 792 { 793 if (Iaux< 0) 794 Iaux=0x7FFFFFFF; 795 } 796 else if ((Iaux2.e[i]<0)&&(Iaux3.e[i]<0)) 797 { 798 if (Iaux> 0) 799 Iaux=0x80000000; 800 } 801 if (Iaux1.e[i] != Iaux) 802 err++; 803 } 804 if (err) 805 printf("Function vec_adds [type integer] ===> Error\n"); 806 else 807 printf("Function vec_adds [type integer] ===> OK\n"); 808 809 err = 0; 810 UIaux1.v = vec_adds( UIcons1, UIcons3 ); 811 UIaux2.v = UIcons1; 812 UIaux3.v = UIcons3; 813 for( i=0; i< 4; i++ ) 814 { 815 UIaux = (unsigned int)(UIaux2.e[i]+UIaux3.e[i]); 816 if ((UIaux< UIaux2.e[i]) || (UIaux< UIaux3.e[i])) 817 UIaux=0xFFFFFFFF; 818 if (UIaux1.e[i] != UIaux) 819 err++; 820 } 821 if (err) 822 printf("Function vec_adds [type unsigned int] ===> Error\n"); 823 else 824 printf("Function vec_adds [type unsigned int] ===> OK\n"); 825 826 /* Function vec_and */ 827 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 828 err = 0; 829 Caux1.v = vec_and( Ccons1, Ccons2 ); 830 Caux2.v = Ccons1; 831 Caux3.v = Ccons2; 832 for( i=0; i< 16; i++ ) 833 if (Caux1.e[i] != (Caux2.e[i] & Caux3.e[i])) 834 err++; 835 if (err) 836 printf("Function vec_and [type char] ===> Error\n"); 837 else 838 printf("Function vec_and [type char] ===> OK\n"); 839 840 err = 0; 841 UCaux1.v = vec_and( UCcons1, UCcons2 ); 842 UCaux2.v = UCcons1; 843 UCaux3.v = UCcons2; 844 for( i=0; i< 16; i++ ) 845 if (UCaux1.e[i] != (UCaux2.e[i] & UCaux3.e[i])) 846 err++; 847 if (err) 848 printf("Function vec_and [type unsigned char] ===> Error\n"); 849 else 850 printf("Function vec_and [type unsigned char] ===> OK\n"); 851 852 err = 0; 853 Saux1.v = vec_and( Scons1, Scons2 ); 854 Saux2.v = Scons1; 855 Saux3.v = Scons2; 856 for( i=0; i< 8; i++ ) 857 if (Saux1.e[i] != (Saux2.e[i] & Saux3.e[i])) 858 err++; 859 if (err) 860 printf("Function vec_and [type short] ===> Error\n"); 861 else 862 printf("Function vec_and [type short] ===> OK\n"); 863 864 err = 0; 865 USaux1.v = vec_and( UScons1, UScons2 ); 866 USaux2.v = UScons1; 867 USaux3.v = UScons2; 868 for( i=0; i< 8; i++ ) 869 if (USaux1.e[i] != (USaux2.e[i] & USaux3.e[i])) 870 err++; 871 if (err) 872 printf("Function vec_and [type unsigned short] ===> Error\n"); 873 else 874 printf("Function vec_and [type unsigned short] ===> OK\n"); 875 876 err = 0; 877 Iaux1.v = vec_and( Icons1, Icons2 ); 878 Iaux2.v = Icons1; 879 Iaux3.v = Icons2; 880 for( i=0; i< 4; i++ ) 881 if (Iaux1.e[i] != (Iaux2.e[i] & Iaux3.e[i])) 882 err++; 883 if (err) 884 printf("Function vec_and [type integer] ===> Error\n"); 885 else 886 printf("Function vec_and [type integer] ===> OK\n"); 887 888 err = 0; 889 UIaux1.v = vec_and( UIcons1, UIcons2 ); 890 UIaux2.v = UIcons1; 891 UIaux3.v = UIcons2; 892 for( i=0; i< 4; i++ ) 893 if (UIaux1.e[i] != (UIaux2.e[i] & UIaux3.e[i])) 894 err++; 895 if (err) 896 printf("Function vec_and [type unsigned int] ===> Error\n"); 897 else 898 printf("Function vec_and [type unsigned int] ===> OK\n"); 899 900 #if defined TEST_FLOATS 901 err = 0; 902 Faux1.v = vec_and( Fcons1, Fcons2 ); 903 Faux2.v = Fcons1; 904 Faux3.v = Fcons2; 905 for( i=0; i< 4; i++ ) 906 { 907 Ivec1 = Faux1.i[i]; 908 Ivec2 = Faux2.i[i]; 909 Ivec3 = Faux3.i[i]; 910 if ((Ivec1) != ((Ivec2) & (Ivec3))) 911 err++; 912 } 913 if (err) 914 printf("Function vec_and [type float] ===> Error\n"); 915 else 916 printf("Function vec_and [type float] ===> OK\n"); 917 #endif 918 919 /* Function vec_andc */ 920 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 921 err = 0; 922 Caux1.v = vec_andc( Ccons1, Ccons2 ); 923 Caux2.v = Ccons1; 924 Caux3.v = Ccons2; 925 for( i=0; i< 16; i++ ) 926 if (Caux1.e[i] != (Caux2.e[i] & ~Caux3.e[i])) 927 err++; 928 if (err) 929 printf("Function vec_andc [type char] ===> Error\n"); 930 else 931 printf("Function vec_andc [type char] ===> OK\n"); 932 933 err = 0; 934 UCaux1.v = vec_andc( UCcons1, UCcons2 ); 935 UCaux2.v = UCcons1; 936 UCaux3.v = UCcons2; 937 for( i=0; i< 16; i++ ) 938 if (UCaux1.e[i] != (UCaux2.e[i] & ~UCaux3.e[i])) 939 err++; 940 if (err) 941 printf("Function vec_andc [type unsigned char] ===> Error\n"); 942 else 943 printf("Function vec_andc [type unsigned char] ===> OK\n"); 944 945 err = 0; 946 Saux1.v = vec_andc( Scons1, Scons2 ); 947 Saux2.v = Scons1; 948 Saux3.v = Scons2; 949 for( i=0; i< 8; i++ ) 950 if (Saux1.e[i] != (Saux2.e[i] & ~Saux3.e[i])) 951 err++; 952 if (err) 953 printf("Function vec_andc [type short] ===> Error\n"); 954 else 955 printf("Function vec_andc [type short] ===> OK\n"); 956 957 err = 0; 958 USaux1.v = vec_andc( UScons1, UScons2 ); 959 USaux2.v = UScons1; 960 USaux3.v = UScons2; 961 for( i=0; i< 8; i++ ) 962 if (USaux1.e[i] != (USaux2.e[i] & ~USaux3.e[i])) 963 err++; 964 if (err) 965 printf("Function vec_andc [type unsigned short] ===> Error\n"); 966 else 967 printf("Function vec_andc [type unsigned short] ===> OK\n"); 968 969 err = 0; 970 Iaux1.v = vec_andc( Icons1, Icons2 ); 971 Iaux2.v = Icons1; 972 Iaux3.v = Icons2; 973 for( i=0; i< 4; i++ ) 974 if (Iaux1.e[i] != (Iaux2.e[i] & ~Iaux3.e[i])) 975 err++; 976 if (err) 977 printf("Function vec_andc [type integer] ===> Error\n"); 978 else 979 printf("Function vec_andc [type integer] ===> OK\n"); 980 981 err = 0; 982 UIaux1.v = vec_andc( UIcons1, UIcons2 ); 983 UIaux2.v = UIcons1; 984 UIaux3.v = UIcons2; 985 for( i=0; i< 4; i++ ) 986 if (UIaux1.e[i] != (UIaux2.e[i] & ~UIaux3.e[i])) 987 err++; 988 if (err) 989 printf("Function vec_andc [type unsigned int] ===> Error\n"); 990 else 991 printf("Function vec_andc [type unsigned int] ===> OK\n"); 992 993 #if defined TEST_FLOATS 994 err = 0; 995 Faux1.v = vec_andc( Fcons1, Fcons2 ); 996 Faux2.v = Fcons1; 997 Faux3.v = Fcons2; 998 for( i=0; i< 4; i++ ) 999 { 1000 Ivec1 = Faux1.i[i]; 1001 Ivec2 = Faux2.i[i]; 1002 Ivec3 = Faux3.i[i]; 1003 if ((Ivec1) != ((Ivec2) & ~(Ivec3))) 1004 err++; 1005 } 1006 if (err) 1007 printf("Function vec_andc [type float] ===> Error\n"); 1008 else 1009 printf("Function vec_andc [type float] ===> OK\n"); 1010 #endif 1011 1012 /* Function vec_avg */ 1013 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1014 err = 0; 1015 Caux1.v = vec_avg( Ccons1, Ccons2 ); 1016 Caux2.v = Ccons1; 1017 Caux3.v = Ccons2; 1018 for( i=0; i< 16; i++ ) 1019 { 1020 j = (Caux2.e[i]+Caux3.e[i]+1) >> 1; 1021 if (Caux1.e[i] != j) 1022 err++; 1023 } 1024 if (err) 1025 printf("Function vec_avg [type char] ===> Error\n"); 1026 else 1027 printf("Function vec_avg [type char] ===> OK\n"); 1028 1029 err = 0; 1030 UCaux1.v = vec_avg( UCcons1, UCcons2 ); 1031 UCaux2.v = UCcons1; 1032 UCaux3.v = UCcons2; 1033 for( i=0; i< 16; i++ ) 1034 { 1035 j = (UCaux2.e[i]+UCaux3.e[i]+1) >> 1; 1036 if (UCaux1.e[i] != j) 1037 err++; 1038 } 1039 if (err) 1040 printf("Function vec_avg [type unsigned char] ===> Error\n"); 1041 else 1042 printf("Function vec_avg [type unsigned char] ===> OK\n"); 1043 1044 err = 0; 1045 Saux1.v = vec_avg( Scons1, Scons2 ); 1046 Saux2.v = Scons1; 1047 Saux3.v = Scons2; 1048 for( i=0; i< 8; i++ ) 1049 { 1050 j = (Saux2.e[i]+Saux3.e[i]+1) >> 1; 1051 if (Saux1.e[i] != j) 1052 err++; 1053 } 1054 if (err) 1055 printf("Function vec_avg [type short] ===> Error\n"); 1056 else 1057 printf("Function vec_avg [type short] ===> OK\n"); 1058 1059 err = 0; 1060 USaux1.v = vec_avg( UScons1, UScons2 ); 1061 USaux2.v = UScons1; 1062 USaux3.v = UScons2; 1063 for( i=0; i< 8; i++ ) 1064 { 1065 j = (USaux2.e[i]+USaux3.e[i]+1) >> 1; 1066 if (USaux1.e[i] != j) 1067 err++; 1068 } 1069 if (err) 1070 printf("Function vec_avg [type unsigned short] ===> Error\n"); 1071 else 1072 printf("Function vec_avg [type unsigned short] ===> OK\n"); 1073 1074 err = 0; 1075 Iaux1.v = vec_avg( Icons1, Icons2 ); 1076 Iaux2.v = Icons1; 1077 Iaux3.v = Icons2; 1078 for( i=0; i< 4; i++ ) 1079 { 1080 Iaux = Iaux2.e[i]%2; 1081 if (Iaux2.e[i]<0) 1082 Iaux = -Iaux; 1083 1084 if (Iaux3.e[i]<0) 1085 Iaux = (Iaux - Iaux3.e[i]%2 + 1)>>1; 1086 else 1087 Iaux = (Iaux + Iaux3.e[i]%2 + 1)>>1; 1088 Iaux = (Iaux2.e[i] >> 1) + (Iaux3.e[i] >> 1) + Iaux; 1089 if (Iaux1.e[i] != Iaux) 1090 err++; 1091 } 1092 if (err) 1093 printf("Function vec_avg [type integer] ===> Error\n"); 1094 else 1095 printf("Function vec_avg [type integer] ===> OK\n"); 1096 1097 err = 0; 1098 UIaux1.v = vec_avg( UIcons1, UIcons2 ); 1099 UIaux2.v = UIcons1; 1100 UIaux3.v = UIcons2; 1101 for( i=0; i< 4; i++ ) 1102 { 1103 UIaux = (UIaux2.e[i] >> 1) + (UIaux3.e[i] >> 1) + 1104 ((UIaux2.e[i]%2 + UIaux3.e[i]%2 + 1 )>>1); 1105 if (UIaux1.e[i] != UIaux) 1106 err++; 1107 } 1108 if (err) 1109 printf("Function vec_avg [type unsigned int] ===> Error\n"); 1110 else 1111 printf("Function vec_avg [type unsigned int] ===> OK\n"); 1112 1113 #if defined TEST_FLOATS 1114 /* Function vec_ceil */ 1115 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1116 err = 0; 1117 Faux1.v = vec_ceil( Fcons1 ); 1118 Faux2.v = Fcons1; 1119 for( i=0; i< 4; i++ ) 1120 if (Faux1.e[i] != ceil(Faux2.e[i])) 1121 err++; 1122 if (err) 1123 printf("Function vec_ceil [type float] ===> Error\n"); 1124 else 1125 printf("Function vec_ceil [type float] ===> OK\n"); 1126 #endif 1127 1128 #if defined TEST_FLOATS 1129 /* Function vec_cmpb */ 1130 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1131 err = 0; 1132 Iaux1.v = vec_cmpb( Fcons1, Fcons2 ); 1133 Faux2.v = Fcons1; 1134 Faux3.v = Fcons2; 1135 for( i=0; i< 4; i++ ) 1136 { 1137 j = 0; 1138 if (Faux2.e[i]>Faux3.e[i]) 1139 j+=(1 << 31); 1140 if (Faux2.e[i]<-Faux3.e[i]) 1141 j+=(1 << 30); 1142 if (Iaux1.e[i] != j) 1143 err++; 1144 } 1145 1146 if (err) 1147 printf("Function vec_cmpb [type float] ===> Error\n"); 1148 else 1149 printf("Function vec_cmpb [type float] ===> OK\n"); 1150 #endif 1151 1152 /* Function vec_cmpeq */ 1153 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1154 err = 0; 1155 BCaux1.v = vec_cmpeq( Ccons1, Ccons2 ); 1156 Caux2.v = Ccons1; 1157 Caux3.v = Ccons2; 1158 for( i=0; i< 16; i++ ) 1159 { 1160 if (Caux2.e[i] == Caux3.e[i]) 1161 BCaux = 0xFF; 1162 else 1163 BCaux = 0; 1164 if (BCaux1.e[i] != BCaux) 1165 err++; 1166 } 1167 if (err) 1168 printf("Function vec_cmpeq [type char] ===> Error\n"); 1169 else 1170 printf("Function vec_cmpeq [type char] ===> OK\n"); 1171 1172 err = 0; 1173 BCaux1.v = vec_cmpeq( UCcons1, UCcons2 ); 1174 UCaux2.v = UCcons1; 1175 UCaux3.v = UCcons2; 1176 for( i=0; i< 16; i++ ) 1177 { 1178 if (UCaux2.e[i] == UCaux3.e[i]) 1179 BCaux = 0xFF; 1180 else 1181 BCaux = 0; 1182 if (BCaux1.e[i] != BCaux) 1183 err++; 1184 } 1185 if (err) 1186 printf("Function vec_cmpeq [type unsigned char] ===> Error\n"); 1187 else 1188 printf("Function vec_cmpeq [type unsigned char] ===> OK\n"); 1189 1190 err = 0; 1191 BSaux1.v = vec_cmpeq( Scons1, Scons2 ); 1192 Saux2.v = Scons1; 1193 Saux3.v = Scons2; 1194 for( i=0; i< 8; i++ ) 1195 { 1196 if (Saux2.e[i] == Saux3.e[i]) 1197 BSaux = 0xFFFF; 1198 else 1199 BSaux = 0; 1200 if (BSaux1.e[i] != BSaux) 1201 err++; 1202 } 1203 if (err) 1204 printf("Function vec_cmpeq [type short] ===> Error\n"); 1205 else 1206 printf("Function vec_cmpeq [type short] ===> OK\n"); 1207 1208 err = 0; 1209 BSaux1.v = vec_cmpeq( UScons1, UScons2 ); 1210 USaux2.v = UScons1; 1211 USaux3.v = UScons2; 1212 for( i=0; i< 8; i++ ) 1213 { 1214 if (USaux2.e[i] == USaux3.e[i]) 1215 BSaux = 0xFFFF; 1216 else 1217 BSaux = 0; 1218 if (BSaux1.e[i] != BSaux) 1219 err++; 1220 } 1221 if (err) 1222 printf("Function vec_cmpeq [type unsigned short] ===> Error\n"); 1223 else 1224 printf("Function vec_cmpeq [type unsigned short] ===> OK\n"); 1225 1226 err = 0; 1227 BIaux1.v = vec_cmpeq( Icons1, Icons2 ); 1228 Iaux2.v = Icons1; 1229 Iaux3.v = Icons2; 1230 for( i=0; i< 4; i++ ) 1231 { 1232 if (Iaux2.e[i] == Iaux3.e[i]) 1233 BIaux = 0xFFFFFFFF; 1234 else 1235 BIaux = 0; 1236 if (BIaux1.e[i] != BIaux) 1237 err++; 1238 } 1239 if (err) 1240 printf("Function vec_cmpeq [type integer] ===> Error\n"); 1241 else 1242 printf("Function vec_cmpeq [type integer] ===> OK\n"); 1243 1244 err = 0; 1245 BIaux1.v = vec_cmpeq( UIcons1, UIcons2 ); 1246 UIaux2.v = UIcons1; 1247 UIaux3.v = UIcons2; 1248 for( i=0; i< 4; i++ ) 1249 { 1250 if (UIaux2.e[i] == UIaux3.e[i]) 1251 BIaux = 0xFFFFFFFF; 1252 else 1253 BIaux = 0; 1254 if (BIaux1.e[i] != BIaux) 1255 err++; 1256 } 1257 if (err) 1258 printf("Function vec_cmpeq [type unsigned int] ===> Error\n"); 1259 else 1260 printf("Function vec_cmpeq [type unsigned int] ===> OK\n"); 1261 1262 #if defined TEST_FLOATS 1263 err = 0; 1264 BIaux1.v = vec_cmpeq( Fcons1, Fcons2 ); 1265 Faux2.v = Fcons1; 1266 Faux3.v = Fcons2; 1267 for( i=0; i< 4; i++ ) 1268 { 1269 if (Faux2.e[i] == Faux3.e[i]) 1270 BIaux = 0xFFFFFFFF; 1271 else 1272 BIaux = 0; 1273 if (BIaux1.e[i] != BIaux) 1274 err++; 1275 } 1276 if (err) 1277 printf("Function vec_cmpeq [type float] ===> Error\n"); 1278 else 1279 printf("Function vec_cmpeq [type float] ===> OK\n"); 1280 #endif 1281 1282 #if defined TEST_FLOATS 1283 /* Function vec_cmpge */ 1284 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1285 err = 0; 1286 BIaux1.v = vec_cmpge( Fcons1, Fcons2 ); 1287 Faux2.v = Fcons1; 1288 Faux3.v = Fcons2; 1289 for( i=0; i< 4; i++ ) 1290 { 1291 if (Faux2.e[i] >= Faux3.e[i]) 1292 BIaux = 0xFFFFFFFF; 1293 else 1294 BIaux = 0; 1295 if (BIaux1.e[i] != BIaux) 1296 err++; 1297 } 1298 if (err) 1299 printf("Function vec_cmpge [type float] ===> Error\n"); 1300 else 1301 printf("Function vec_cmpge [type float] ===> OK\n"); 1302 #endif 1303 1304 /* Function vec_cmpgt */ 1305 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1306 err = 0; 1307 BCaux1.v = vec_cmpgt( Ccons1, Ccons2 ); 1308 Caux2.v = Ccons1; 1309 Caux3.v = Ccons2; 1310 for( i=0; i< 16; i++ ) 1311 { 1312 if (Caux2.e[i] > Caux3.e[i]) 1313 BCaux = 0xFF; 1314 else 1315 BCaux = 0; 1316 if (BCaux1.e[i] != BCaux) 1317 err++; 1318 } 1319 if (err) 1320 printf("Function vec_cmpgt [type char] ===> Error\n"); 1321 else 1322 printf("Function vec_cmpgt [type char] ===> OK\n"); 1323 1324 err = 0; 1325 BCaux1.v = vec_cmpgt( UCcons1, UCcons2 ); 1326 UCaux2.v = UCcons1; 1327 UCaux3.v = UCcons2; 1328 for( i=0; i< 16; i++ ) 1329 { 1330 if (UCaux2.e[i] > UCaux3.e[i]) 1331 BCaux = 0xFF; 1332 else 1333 BCaux = 0; 1334 if (BCaux1.e[i] != BCaux) 1335 err++; 1336 } 1337 if (err) 1338 printf("Function vec_cmpgt [type unsigned char] ===> Error\n"); 1339 else 1340 printf("Function vec_cmpgt [type unsigned char] ===> OK\n"); 1341 1342 err = 0; 1343 BSaux1.v = vec_cmpgt( Scons1, Scons2 ); 1344 Saux2.v = Scons1; 1345 Saux3.v = Scons2; 1346 for( i=0; i< 8; i++ ) 1347 { 1348 if (Saux2.e[i] > Saux3.e[i]) 1349 BSaux = 0xFFFF; 1350 else 1351 BSaux = 0; 1352 if (BSaux1.e[i] != BSaux) 1353 err++; 1354 } 1355 if (err) 1356 printf("Function vec_cmpgt [type short] ===> Error\n"); 1357 else 1358 printf("Function vec_cmpgt [type short] ===> OK\n"); 1359 1360 err = 0; 1361 BSaux1.v = vec_cmpgt( UScons1, UScons2 ); 1362 USaux2.v = UScons1; 1363 USaux3.v = UScons2; 1364 for( i=0; i< 8; i++ ) 1365 { 1366 if (USaux2.e[i] > USaux3.e[i]) 1367 BSaux = 0xFFFF; 1368 else 1369 BSaux = 0; 1370 if (BSaux1.e[i] != BSaux) 1371 err++; 1372 } 1373 if (err) 1374 printf("Function vec_cmpgt [type unsigned short] ===> Error\n"); 1375 else 1376 printf("Function vec_cmpgt [type unsigned short] ===> OK\n"); 1377 1378 err = 0; 1379 BIaux1.v = vec_cmpgt( Icons1, Icons2 ); 1380 Iaux2.v = Icons1; 1381 Iaux3.v = Icons2; 1382 for( i=0; i< 4; i++ ) 1383 { 1384 if (Iaux2.e[i] > Iaux3.e[i]) 1385 BIaux = 0xFFFFFFFF; 1386 else 1387 BIaux = 0; 1388 if (BIaux1.e[i] != BIaux) 1389 err++; 1390 } 1391 if (err) 1392 printf("Function vec_cmpgt [type integer] ===> Error\n"); 1393 else 1394 printf("Function vec_cmpgt [type integer] ===> OK\n"); 1395 1396 err = 0; 1397 BIaux1.v = vec_cmpgt( UIcons1, UIcons2 ); 1398 UIaux2.v = UIcons1; 1399 UIaux3.v = UIcons2; 1400 for( i=0; i< 4; i++ ) 1401 { 1402 if (UIaux2.e[i] > UIaux3.e[i]) 1403 BIaux=0xFFFFFFFF; 1404 else 1405 BIaux = 0; 1406 if (BIaux1.e[i] != BIaux) 1407 err++; 1408 } 1409 if (err) 1410 printf("Function vec_cmpgt [type unsigned int] ===> Error\n"); 1411 else 1412 printf("Function vec_cmpgt [type unsigned int] ===> OK\n"); 1413 1414 #if defined TEST_FLOATS 1415 err = 0; 1416 BIaux1.v = vec_cmpgt( Fcons1, Fcons2 ); 1417 Faux2.v = Fcons1; 1418 Faux3.v = Fcons2; 1419 for( i=0; i< 4; i++ ) 1420 { 1421 if (Faux2.e[i] > Faux3.e[i]) 1422 BIaux = 0xFFFFFFFF; 1423 else 1424 BIaux = 0; 1425 if (BIaux1.e[i] != BIaux) 1426 err++; 1427 } 1428 if (err) 1429 printf("Function vec_cmpgt [type float] ===> Error\n"); 1430 else 1431 printf("Function vec_cmpgt [type float] ===> OK\n"); 1432 #endif 1433 1434 #if defined TEST_FLOATS 1435 /* Function vec_cmple */ 1436 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1437 err = 0; 1438 BIaux1.v = vec_cmple( Fcons1, Fcons2 ); 1439 Faux2.v = Fcons1; 1440 Faux3.v = Fcons2; 1441 for( i=0; i< 4; i++ ) 1442 { 1443 if (Faux2.e[i] <= Faux3.e[i]) 1444 BIaux = 0xFFFFFFFF; 1445 else 1446 BIaux = 0; 1447 if (BIaux1.e[i] != BIaux) 1448 err++; 1449 } 1450 if (err) 1451 printf("Function vec_cmple [type float] ===> Error\n"); 1452 else 1453 printf("Function vec_cmple [type float] ===> OK\n"); 1454 #endif 1455 1456 /* Function vec_cmplt */ 1457 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1458 err = 0; 1459 BCaux1.v = vec_cmplt( Ccons1, Ccons2 ); 1460 Caux2.v = Ccons1; 1461 Caux3.v = Ccons2; 1462 for( i=0; i< 16; i++ ) 1463 { 1464 if (Caux2.e[i] < Caux3.e[i]) 1465 BCaux = 0xFF; 1466 else 1467 BCaux = 0; 1468 if (BCaux1.e[i] != BCaux) 1469 err++; 1470 } 1471 if (err) 1472 printf("Function vec_cmplt [type char] ===> Error\n"); 1473 else 1474 printf("Function vec_cmplt [type char] ===> OK\n"); 1475 1476 err = 0; 1477 BCaux1.v = vec_cmplt( UCcons1, UCcons2 ); 1478 UCaux2.v = UCcons1; 1479 UCaux3.v = UCcons2; 1480 for( i=0; i< 16; i++ ) 1481 { 1482 if (UCaux2.e[i] < UCaux3.e[i]) 1483 BCaux = 0xFF; 1484 else 1485 BCaux = 0; 1486 if (BCaux1.e[i] != BCaux) 1487 err++; 1488 } 1489 if (err) 1490 printf("Function vec_cmplt [type unsigned char] ===> Error\n"); 1491 else 1492 printf("Function vec_cmplt [type unsigned char] ===> OK\n"); 1493 1494 err = 0; 1495 BSaux1.v = vec_cmplt( Scons1, Scons2 ); 1496 Saux2.v = Scons1; 1497 Saux3.v = Scons2; 1498 for( i=0; i< 8; i++ ) 1499 { 1500 if (Saux2.e[i] < Saux3.e[i]) 1501 BSaux = 0xFFFF; 1502 else 1503 BSaux = 0; 1504 if (BSaux1.e[i] != BSaux) 1505 err++; 1506 } 1507 if (err) 1508 printf("Function vec_cmplt [type short] ===> Error\n"); 1509 else 1510 printf("Function vec_cmplt [type short] ===> OK\n"); 1511 1512 err = 0; 1513 BSaux1.v = vec_cmplt( UScons1, UScons2 ); 1514 USaux2.v = UScons1; 1515 USaux3.v = UScons2; 1516 for( i=0; i< 8; i++ ) 1517 { 1518 if (USaux2.e[i] < USaux3.e[i]) 1519 BSaux = 0xFFFF; 1520 else 1521 BSaux = 0; 1522 if (BSaux1.e[i] != BSaux) 1523 err++; 1524 } 1525 if (err) 1526 printf("Function vec_cmplt [type unsigned short] ===> Error\n"); 1527 else 1528 printf("Function vec_cmplt [type unsigned short] ===> OK\n"); 1529 1530 err = 0; 1531 BIaux1.v = vec_cmplt( Icons1, Icons2 ); 1532 Iaux2.v = Icons1; 1533 Iaux3.v = Icons2; 1534 for( i=0; i< 4; i++ ) 1535 { 1536 if (Iaux2.e[i] < Iaux3.e[i]) 1537 BIaux = 0xFFFFFFFF; 1538 else 1539 BIaux = 0; 1540 if (BIaux1.e[i] != BIaux) 1541 err++; 1542 } 1543 if (err) 1544 printf("Function vec_cmplt [type integer] ===> Error\n"); 1545 else 1546 printf("Function vec_cmplt [type integer] ===> OK\n"); 1547 1548 err = 0; 1549 BIaux1.v = vec_cmplt( UIcons1, UIcons2 ); 1550 UIaux2.v = UIcons1; 1551 UIaux3.v = UIcons2; 1552 for( i=0; i< 4; i++ ) 1553 { 1554 if (UIaux2.e[i] < UIaux3.e[i]) 1555 BIaux=0xFFFFFFFF; 1556 else 1557 BIaux = 0; 1558 if (BIaux1.e[i] != BIaux) 1559 err++; 1560 } 1561 if (err) 1562 printf("Function vec_cmplt [type unsigned int] ===> Error\n"); 1563 else 1564 printf("Function vec_cmplt [type unsigned int] ===> OK\n"); 1565 1566 #if defined TEST_FLOATS 1567 err = 0; 1568 BIaux1.v = vec_cmplt( Fcons1, Fcons2 ); 1569 Faux2.v = Fcons1; 1570 Faux3.v = Fcons2; 1571 for( i=0; i< 4; i++ ) 1572 { 1573 if (Faux2.e[i] < Faux3.e[i]) 1574 BIaux = 0xFFFFFFFF; 1575 else 1576 BIaux = 0; 1577 if (BIaux1.e[i] != BIaux) 1578 err++; 1579 } 1580 if (err) 1581 printf("Function vec_cmplt [type float] ===> Error\n"); 1582 else 1583 printf("Function vec_cmplt [type float] ===> OK\n"); 1584 #endif 1585 1586 #if defined TEST_FLOATS 1587 /* Function vec_ctf */ 1588 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1589 err = 0; 1590 b = 2; 1591 Faux1.v = vec_ctf( Icons1, 2 ); 1592 Iaux1.v = Icons1; 1593 for( i=0; i< 4; i++ ) 1594 if (Faux1.e[i] != (((float)Iaux1.e[i])/(1<<b))) 1595 err++; 1596 if (err) 1597 printf("Function vec_ctf [type integer] ===> Error\n"); 1598 else 1599 printf("Function vec_ctf [type integer] ===> OK\n"); 1600 1601 err = 0; 1602 b = 2; 1603 Faux1.v = vec_ctf( UIcons1, 2 ); 1604 UIaux1.v = UIcons1; 1605 for( i=0; i< 4; i++ ) 1606 if (Faux1.e[i] != (((float)UIaux1.e[i])/(1<<b))) 1607 err++; 1608 if (err) 1609 printf("Function vec_ctf [type unsigned int] ===> Error\n"); 1610 else 1611 printf("Function vec_ctf [type unsigned int] ===> OK\n"); 1612 #endif 1613 1614 #if defined TEST_FLOATS 1615 /* Function vec_cts */ 1616 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1617 err = 0; 1618 b = 2; 1619 Iaux1.v = vec_cts( Fcons3, 2 ); 1620 Faux1.v = Fcons3; 1621 for( i=0; i< 4; i++ ) 1622 if (Iaux1.e[i] != (int)(Faux1.e[i]*(1<<b))) 1623 err++; 1624 if (err) 1625 printf("Function vec_cts [type float] ===> Error\n"); 1626 else 1627 printf("Function vec_cts [type float] ===> OK\n"); 1628 #endif 1629 1630 #if defined TEST_FLOATS 1631 /* Function vec_ctu */ 1632 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1633 err = 0; 1634 b = 2; 1635 UIaux1.v = vec_ctu( Fcons3, 2 ); 1636 Faux1.v = Fcons3; 1637 for( i=0; i< 4; i++ ) 1638 { 1639 double d = Faux1.e[i]*(1<<b); 1640 if (d > 0xffffffff) 1641 d = 0xffffffff; 1642 if (d < 0) 1643 d = 0; 1644 if (UIaux1.e[i] != (unsigned int)(d)) 1645 err++; 1646 } 1647 if (err) 1648 printf("Function vec_ctu [type float] ===> Error\n"); 1649 else 1650 printf("Function vec_ctu [type float] ===> OK\n"); 1651 #endif 1652 1653 part1(); 1654 1655 part2(); 1656 1657 part3(); 1658 1659 part4(); 1660 1661 part5(); 1662 1663 return 0; 1664 } 1665 1666 1667 1668 1669 int part1() 1670 { 1671 TvecChar Caux1;//, Caux2, Caux3, Caux4; 1672 TvecUChar UCaux1;//, UCaux2, UCaux3, UCaux4; 1673 TvecShort Saux1;//, Saux2, Saux3, Saux4; 1674 TvecUShort USaux1;//, USaux2, USaux3, USaux4; 1675 TvecInt Iaux1;//, Iaux2, Iaux3, Iaux4; 1676 TvecUInt UIaux1;//, UIaux2, UIaux3, UIaux4; 1677 #if defined TEST_FLOATS 1678 TvecFloat Faux1, Faux2;//, Faux3, Faux4; 1679 #endif 1680 1681 int i, err, j;//, b, bAux; 1682 // signed int Ivec1, Ivec2, Ivec3; 1683 // signed short *Svec1; 1684 // unsigned int *UIvec1; 1685 // unsigned short *USvec1; 1686 // unsigned char *UCvec1; 1687 #if defined TEST_FLOATS 1688 // float *Fvec1; 1689 #endif 1690 1691 /* For saturated rutines */ 1692 // long long int LLaux; 1693 1694 #if defined TEST_FLOATS 1695 float Faux; 1696 #endif 1697 signed int Iaux;//, I1, I2; 1698 // unsigned int UIaux, UI1, UI2; 1699 // signed short Saux; 1700 // unsigned short USaux; 1701 // signed char Caux; 1702 // unsigned char UCaux; 1703 1704 /* 1705 union 1706 { 1707 float f; 1708 signed int si; 1709 unsigned int ui; 1710 signed short ss[2]; 1711 unsigned short us[2]; 1712 signed char sc[4]; 1713 unsigned char uc[4]; 1714 } INTunion1, INTunion2; 1715 1716 union 1717 { 1718 signed short ss; 1719 unsigned short us; 1720 signed char sc[2]; 1721 unsigned char uc[2]; 1722 } SHOunion1, SHOunion2; 1723 */ 1724 1725 #if defined (GCC_COMPILER) 1726 vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 1727 // vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 1728 // vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127}; 1729 vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7}; 1730 // vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; 1731 // vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}; 1732 vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3}; 1733 // vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000}; 1734 // vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767}; 1735 // vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3}; 1736 // vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1}; 1737 vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4}; 1738 vector signed int Icons1 = (vector signed int){-4, -1, 1, 4}; 1739 // vector signed int Icons2 = (vector signed int){1, 1, 1, 1}; 1740 // vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF}; 1741 vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1}; 1742 // vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1}; 1743 // vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2}; 1744 1745 #if defined TEST_FLOATS 1746 vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999}; 1747 // vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0}; 1748 vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0}; 1749 #endif 1750 1751 #elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 1752 vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 1753 vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); 1754 vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127); 1755 vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7); 1756 vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2); 1757 vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8); 1758 vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3); 1759 vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000); 1760 vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767); 1761 vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3); 1762 vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1); 1763 vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4); 1764 vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4); 1765 vector signed int Icons2 = (vector signed int)(1, 1, 1, 1); 1766 vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF); 1767 vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1); 1768 vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1); 1769 vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2); 1770 1771 #if defined TEST_FLOATS 1772 vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999); 1773 vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0); 1774 vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0); 1775 #endif 1776 1777 #endif 1778 1779 1780 /* Variables to be allocated with calloc_vec (16 bytes aligned) */ 1781 unsigned char *UCmem = (unsigned char*)calloc_vec( 1, sizeof(vector unsigned char) ); 1782 signed char *Cmem = (signed char*)calloc_vec( 1, sizeof(vector signed char) ); 1783 unsigned short *USmem = (unsigned short*)calloc_vec( 1, sizeof(vector unsigned short) ); 1784 signed short *Smem = (signed short*)calloc_vec( 1, sizeof(vector signed short) ); 1785 unsigned int *UImem = (unsigned int*)calloc_vec( 1, sizeof(vector unsigned int) ); 1786 signed int *Imem = (signed int*)calloc_vec( 1, sizeof(vector signed int) ); 1787 #if defined TEST_FLOATS 1788 float *Fmem = (float*)calloc_vec( 1, sizeof(vector float) ); 1789 #endif 1790 1791 /* Function vec_dss */ 1792 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1793 printf("Function vec_dss [Vector data Stream Stop] not checked\n"); 1794 1795 /* Function vec_dssall */ 1796 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1797 printf("Function vec_dssall [Vector Stream Stop all] not checked\n"); 1798 1799 /* Function vec_dst */ 1800 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1801 printf("Function vec_dst [Vector Data Stream Touch] not checked\n"); 1802 1803 /* Function vec_dstst */ 1804 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1805 printf("Function vec_dstst [Vector Data Stream Touch for Store] not checked\n"); 1806 1807 /* Function vec_dststt */ 1808 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1809 printf("Function vec_dststt [Vector Data Stream Touch for Store Transient] not checked\n"); 1810 1811 /* Function vec_dstt */ 1812 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1813 printf("Function vec_dstt [Vector Data Stream Touch Transient] not checked\n"); 1814 1815 #if defined TEST_FLOATS 1816 /* Function vec_expte */ 1817 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1818 err = 0; 1819 Faux1.v = vec_expte( Fcons1 ); 1820 Faux2.v = Fcons1; 1821 for( i=0; i< 4; i++ ) 1822 { 1823 Faux = pow(2,Faux2.e[i]); 1824 /* 1825 Ivec1 = (signed int*)(&Faux1.e[i]); 1826 Ivec2 = (signed int*)(&Faux); 1827 *Ivec1 = (*Ivec1) & 0xFFF00000; 1828 *Ivec2 = (*Ivec2) & 0xFFF00000; 1829 if (Faux1.e[i] != Faux) 1830 err++; 1831 */ 1832 Faux = (Faux - Faux1.e[i])/Faux; 1833 if (Faux>0.1) 1834 err++; 1835 } 1836 if (err) 1837 printf("Function vec_expte [type float] ===> Error\n"); 1838 else 1839 printf("Function vec_expte [type float] ===> OK\n"); 1840 #endif 1841 1842 #if defined TEST_FLOATS 1843 /* Function vec_floor */ 1844 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1845 err = 0; 1846 Faux1.v = vec_floor( Fcons1 ); 1847 Faux2.v = Fcons1; 1848 for( i=0; i< 4; i++ ) 1849 if (Faux1.e[i] != floor(Faux2.e[i])) 1850 err++; 1851 if (err) 1852 printf("Function vec_floor [type float] ===> Error\n"); 1853 else 1854 printf("Function vec_floor [type float] ===> OK\n"); 1855 #endif 1856 1857 /* Function vec_ld */ 1858 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1859 err = 0; 1860 memcpy( UCmem, &UCcons1, sizeof(vector unsigned char) ); 1861 UCaux1.v = vec_ld( 0, UCmem ); 1862 Iaux = 1; 1863 for ( i=0; i< 16; i++ ) 1864 { 1865 Iaux = Iaux && (UCaux1.e[i]==UCmem[i]); 1866 } 1867 if (Iaux!=1) err++; 1868 1869 if (err) 1870 printf("Function vec_ld [type unsigned char] ===> Error\n"); 1871 else 1872 printf("Function vec_ld [type unsigned char] ===> OK\n"); 1873 1874 err = 0; 1875 memcpy( Cmem, &Ccons1, sizeof(vector signed char) ); 1876 Caux1.v = vec_ld( 0, Cmem ); 1877 Iaux = 1; 1878 for ( i=0; i< 16; i++ ) 1879 { 1880 Iaux = Iaux && (Caux1.e[i]==Cmem[i]); 1881 } 1882 if (Iaux!=1) err++; 1883 1884 if (err) 1885 printf("Function vec_ld [type char] ===> Error\n"); 1886 else 1887 printf("Function vec_ld [type char] ===> OK\n"); 1888 1889 err = 0; 1890 memcpy( USmem, &UScons3, sizeof(vector unsigned short) ); 1891 USaux1.v = vec_ld( 0, USmem ); 1892 Iaux = 1; 1893 for ( i=0; i< 8; i++ ) 1894 { 1895 Iaux = Iaux && (USaux1.e[i]==USmem[i]); 1896 } 1897 if (Iaux!=1) err++; 1898 1899 if (err) 1900 printf("Function vec_ld [type unsigned short] ===> Error\n"); 1901 else 1902 printf("Function vec_ld [type unsigned short] ===> OK\n"); 1903 1904 err = 0; 1905 memcpy( Smem, &Scons1, sizeof(vector signed short) ); 1906 Saux1.v = vec_ld( 0, Smem ); 1907 Iaux = 1; 1908 for ( i=0; i< 8; i++ ) 1909 { 1910 Iaux = Iaux && (Saux1.e[i]==Smem[i]); 1911 } 1912 if (Iaux!=1) err++; 1913 1914 if (err) 1915 printf("Function vec_ld [type short] ===> Error\n"); 1916 else 1917 printf("Function vec_ld [type short] ===> OK\n"); 1918 1919 err = 0; 1920 memcpy( UImem, &UIcons1, sizeof(vector unsigned int) ); 1921 UIaux1.v = vec_ld( 0, UImem ); 1922 Iaux = 1; 1923 for ( i=0; i< 4; i++ ) 1924 { 1925 Iaux = Iaux && (UIaux1.e[i]==UImem[i]); 1926 } 1927 if (Iaux!=1) err++; 1928 1929 if (err) 1930 printf("Function vec_ld [type unsigned int] ===> Error\n"); 1931 else 1932 printf("Function vec_ld [type unsigned int] ===> OK\n"); 1933 1934 err = 0; 1935 memcpy( Imem, &Icons1, sizeof(vector signed int) ); 1936 Iaux1.v = vec_ld( 0, Imem ); 1937 Iaux = 1; 1938 for ( i=0; i< 4; i++ ) 1939 { 1940 Iaux = Iaux && (Iaux1.e[i]==Imem[i]); 1941 } 1942 if (Iaux!=1) err++; 1943 1944 if (err) 1945 printf("Function vec_ld [type int] ===> Error\n"); 1946 else 1947 printf("Function vec_ld [type int] ===> OK\n"); 1948 1949 #if defined TEST_FLOATS 1950 err = 0; 1951 memcpy( Fmem, &Fcons1, sizeof(vector float) ); 1952 Faux1.v = vec_ld( 0, Fmem ); 1953 Iaux = 1; 1954 for ( i=0; i< 4; i++ ) 1955 { 1956 Iaux = Iaux && (Faux1.e[i]==Fmem[i]); 1957 } 1958 if (Iaux!=1) err++; 1959 1960 if (err) 1961 printf("Function vec_ld [type float] ===> Error\n"); 1962 else 1963 printf("Function vec_ld [type float] ===> OK\n"); 1964 #endif 1965 1966 /* Function vec_lde */ 1967 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 1968 1969 err = 0; 1970 for (i= 0; i< 16; i++) 1971 UCmem[i] = (unsigned char)i; 1972 j = 1; 1973 i = j*sizeof(unsigned char); 1974 UCaux1.v = vec_lde( i, UCmem ); 1975 1976 if (UCaux1.e[j] != UCmem[j]) err++; 1977 1978 if (err) 1979 printf("Function vec_lde [type unsigned char] ===> Error\n"); 1980 else 1981 printf("Function vec_lde [type unsigned char] ===> OK\n"); 1982 1983 err = 0; 1984 for (i= 0; i< 16; i++) 1985 Cmem[i] = (char)(-i); 1986 j = 1; 1987 i = j*sizeof(char); 1988 Caux1.v = vec_lde( i, Cmem ); 1989 1990 if (Caux1.e[j] != Cmem[j]) err++; 1991 1992 if (err) 1993 printf("Function vec_lde [type char] ===> Error\n"); 1994 else 1995 printf("Function vec_lde [type char] ===> OK\n"); 1996 1997 err = 0; 1998 for (i= 0; i< 8; i++) 1999 USmem[i] = (unsigned short)(i); 2000 j = 1; 2001 i = j*sizeof(unsigned short); 2002 USaux1.v = vec_lde( i, USmem ); 2003 2004 if (USaux1.e[j] != USmem[j]) err++; 2005 2006 if (err) 2007 printf("Function vec_lde [type unsigned short] ===> Error\n"); 2008 else 2009 printf("Function vec_lde [type unsigned short] ===> OK\n"); 2010 2011 err = 0; 2012 for (i= 0; i< 8; i++) 2013 Smem[i] = (short)(-i); 2014 j = 1; 2015 i = j*sizeof(short); 2016 Saux1.v = vec_lde( i, Smem ); 2017 2018 if (Saux1.e[j] != Smem[j]) err++; 2019 2020 if (err) 2021 printf("Function vec_lde [type short] ===> Error\n"); 2022 else 2023 printf("Function vec_lde [type short] ===> OK\n"); 2024 2025 err = 0; 2026 for (i= 0; i< 4; i++) 2027 UImem[i] = (unsigned int)(i); 2028 j = 1; 2029 i = j*sizeof(unsigned int); 2030 UIaux1.v = vec_lde( i, UImem ); 2031 2032 if (UIaux1.e[j] != UImem[j]) err++; 2033 2034 if (err) 2035 printf("Function vec_lde [type unsigned int] ===> Error\n"); 2036 else 2037 printf("Function vec_lde [type unsigned int] ===> OK\n"); 2038 2039 err = 0; 2040 for (i= 0; i< 4; i++) 2041 Imem[i] = (int)(-i); 2042 j = 1; 2043 i = j*sizeof(int); 2044 Iaux1.v = vec_lde( i, Imem ); 2045 2046 if (Iaux1.e[j] != Imem[j]) err++; 2047 2048 if (err) 2049 printf("Function vec_lde [type int] ===> Error\n"); 2050 else 2051 printf("Function vec_lde [type int] ===> OK\n"); 2052 2053 #if defined TEST_FLOATS 2054 err = 0; 2055 for (i= 0; i< 4; i++) 2056 Fmem[i] = ((float)(-i)) - 0.5; 2057 j = 1; 2058 i = j*sizeof(float); 2059 Faux1.v = vec_lde( i, Fmem ); 2060 2061 if (Faux1.e[j] != Fmem[j]) err++; 2062 2063 if (err) 2064 printf("Function vec_lde [type float] ===> Error\n"); 2065 else 2066 printf("Function vec_lde [type float] ===> OK\n"); 2067 #endif 2068 2069 #if 0 2070 /* Function vec_ldl */ 2071 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2072 err = 0; 2073 memcpy( UCmem, &UCcons1, sizeof(vector unsigned char) ); 2074 UCaux1.v = vec_ldl( 0, UCmem ); 2075 Iaux = 1; 2076 for ( i=0; i< 16; i++ ) 2077 { 2078 Iaux = Iaux && (UCaux1.e[i]==UCmem[i]); 2079 } 2080 if (Iaux!=1) err++; 2081 2082 if (err) 2083 printf("Function vec_ldl [type unsigned char] ===> Error\n"); 2084 else 2085 printf("Function vec_ldl [type unsigned char] ===> OK\n"); 2086 2087 err = 0; 2088 memcpy( Cmem, &Ccons1, sizeof(vector signed char) ); 2089 Caux1.v = vec_ldl( 0, Cmem ); 2090 Iaux = 1; 2091 for ( i=0; i< 16; i++ ) 2092 { 2093 Iaux = Iaux && (Caux1.e[i]==Cmem[i]); 2094 } 2095 if (Iaux!=1) err++; 2096 2097 if (err) 2098 printf("Function vec_ldl [type char] ===> Error\n"); 2099 else 2100 printf("Function vec_ldl [type char] ===> OK\n"); 2101 2102 err = 0; 2103 memcpy( USmem, &UScons3, sizeof(vector unsigned short) ); 2104 USaux1.v = vec_ldl( 0, USmem ); 2105 Iaux = 1; 2106 for ( i=0; i< 8; i++ ) 2107 { 2108 Iaux = Iaux && (USaux1.e[i]==USmem[i]); 2109 } 2110 if (Iaux!=1) err++; 2111 2112 if (err) 2113 printf("Function vec_ldl [type unsigned short] ===> Error\n"); 2114 else 2115 printf("Function vec_ldl [type unsigned short] ===> OK\n"); 2116 2117 err = 0; 2118 memcpy( Smem, &Scons1, sizeof(vector signed short) ); 2119 Saux1.v = vec_ldl( 0, Smem ); 2120 Iaux = 1; 2121 for ( i=0; i< 8; i++ ) 2122 { 2123 Iaux = Iaux && (Saux1.e[i]==Smem[i]); 2124 } 2125 if (Iaux!=1) err++; 2126 2127 if (err) 2128 printf("Function vec_ldl [type short] ===> Error\n"); 2129 else 2130 printf("Function vec_ldl [type short] ===> OK\n"); 2131 2132 err = 0; 2133 memcpy( UImem, &UIcons1, sizeof(vector unsigned int) ); 2134 UIaux1.v = vec_ldl( 0, UImem ); 2135 Iaux = 1; 2136 for ( i=0; i< 4; i++ ) 2137 { 2138 Iaux = Iaux && (UIaux1.e[i]==UImem[i]); 2139 } 2140 if (Iaux!=1) err++; 2141 2142 if (err) 2143 printf("Function vec_ldl [type unsigned int] ===> Error\n"); 2144 else 2145 printf("Function vec_ldl [type unsigned int] ===> OK\n"); 2146 2147 err = 0; 2148 memcpy( Imem, &Icons1, sizeof(vector signed int) ); 2149 Iaux1.v = vec_ldl( 0, Imem ); 2150 Iaux = 1; 2151 for ( i=0; i< 4; i++ ) 2152 { 2153 Iaux = Iaux && (Iaux1.e[i]==Imem[i]); 2154 } 2155 if (Iaux!=1) err++; 2156 2157 if (err) 2158 printf("Function vec_ldl [type int] ===> Error\n"); 2159 else 2160 printf("Function vec_ldl [type int] ===> OK\n"); 2161 2162 #if defined TEST_FLOATS 2163 err = 0; 2164 memcpy( Fmem, &Fcons1, sizeof(vector float) ); 2165 Faux1.v = vec_ldl( 0, Fmem ); 2166 Iaux = 1; 2167 for ( i=0; i< 4; i++ ) 2168 { 2169 Iaux = Iaux && (Faux1.e[i]==Fmem[i]); 2170 } 2171 if (Iaux!=1) err++; 2172 2173 if (err) 2174 printf("Function vec_ldl [type float] ===> Error\n"); 2175 else 2176 printf("Function vec_ldl [type float] ===> OK\n"); 2177 #endif 2178 #endif // #if 0 2179 2180 /* Free dynamic vector variables */ 2181 free_vec( UCmem ); 2182 free_vec( Cmem ); 2183 free_vec( USmem ); 2184 free_vec( Smem ); 2185 free_vec( UImem ); 2186 free_vec( Imem ); 2187 #if defined TEST_FLOATS 2188 free_vec( Fmem ); 2189 #endif 2190 2191 #if defined TEST_FLOATS 2192 /* Function vec_loge */ 2193 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2194 err = 0; 2195 Faux1.v = vec_loge( Fcons3 ); 2196 Faux2.v = Fcons3; 2197 for( i=0; i< 4; i++ ) 2198 { 2199 Faux = log2(Faux2.e[i]); 2200 if (Faux!=0.0) 2201 Faux = (Faux - Faux1.e[i])/Faux; 2202 else 2203 Faux = Faux - Faux1.e[i]; 2204 if (Faux>0.1) 2205 err++; 2206 } 2207 if (err) 2208 printf("Function vec_loge [type float] ===> Error\n"); 2209 else 2210 printf("Function vec_loge [type float] ===> OK\n"); 2211 #endif 2212 2213 return 0; 2214 } 2215 2216 2217 2218 2219 int part2() 2220 { 2221 TvecChar Caux1, Caux2, Caux3;//, Caux4; 2222 TvecUChar UCaux1, UCaux2, UCaux3;//, UCaux4; 2223 TvecShort Saux1, Saux2, Saux3, Saux4; 2224 TvecUShort USaux1, USaux2, USaux3, USaux4; 2225 TvecInt Iaux1, Iaux2, Iaux3;//, Iaux4; 2226 TvecUInt UIaux1, UIaux2, UIaux3;//, UIaux4; 2227 #if defined TEST_FLOATS 2228 TvecFloat Faux1, Faux2, Faux3, Faux4; 2229 #endif 2230 2231 int i, err, j, b, bAux; 2232 #if defined TEST_FLOATS 2233 signed int Ivec1, Ivec2, Ivec3; 2234 #endif 2235 // signed short *Svec1; 2236 // unsigned int *UIvec1; 2237 // unsigned short *USvec1; 2238 // unsigned char *UCvec1; 2239 #if defined TEST_FLOATS 2240 // float *Fvec1; 2241 #endif 2242 2243 /* For saturated rutines */ 2244 // long long int LLaux; 2245 2246 #if defined TEST_FLOATS 2247 float Faux; 2248 #endif 2249 signed int Iaux, I1, I2; 2250 unsigned int UIaux, UI1, UI2; 2251 signed short Saux; 2252 unsigned short USaux; 2253 signed char Caux; 2254 unsigned char UCaux; 2255 2256 union 2257 { 2258 float f; 2259 signed int si; 2260 unsigned int ui; 2261 signed short ss[2]; 2262 unsigned short us[2]; 2263 signed char sc[4]; 2264 unsigned char uc[4]; 2265 } INTunion1;//, INTunion2; 2266 2267 /* 2268 union 2269 { 2270 signed short ss; 2271 unsigned short us; 2272 signed char sc[2]; 2273 unsigned char uc[2]; 2274 } SHOunion1, SHOunion2; 2275 */ 2276 2277 #if defined (GCC_COMPILER) 2278 vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 2279 vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 2280 // vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127}; 2281 vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7}; 2282 vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; 2283 // vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}; 2284 vector signed short Scons1 = (vector signed short){256, 320, 340, -1, 0, 1, 2, 3}; 2285 vector signed short Scons2 = (vector signed short){256, 320, 340, 1, 1, 1, -10000, -10000}; 2286 vector signed short Scons3 = (vector signed short){256, 320, 340, 32767, -32768, 32767, -32768, 32767}; 2287 vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3}; 2288 vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1}; 2289 vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4}; 2290 vector signed int Icons1 = (vector signed int){-4, -1, 1, 4}; 2291 vector signed int Icons2 = (vector signed int){1, 1, 1, 1}; 2292 vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF}; 2293 vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1}; 2294 vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1}; 2295 vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2}; 2296 2297 #if defined TEST_FLOATS 2298 vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999}; 2299 vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0}; 2300 vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0}; 2301 #endif 2302 2303 #elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 2304 vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 2305 vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); 2306 vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127); 2307 vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7); 2308 vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2); 2309 // vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8); 2310 vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3); 2311 vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000); 2312 vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767); 2313 vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3); 2314 vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1); 2315 vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4); 2316 vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4); 2317 vector signed int Icons2 = (vector signed int)(1, 1, 1, 1); 2318 vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF); 2319 vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1); 2320 vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1); 2321 vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2); 2322 2323 #if defined TEST_FLOATS 2324 vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999); 2325 vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0); 2326 vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0); 2327 #endif 2328 2329 #endif 2330 2331 2332 /* Function vec_lvsl */ 2333 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2334 err = 0; 2335 b = 3; 2336 UCaux1.v = vec_lvsl( b, &b); 2337 bAux = b + (size_t)(&b); 2338 b = bAux & 0xF; 2339 # if defined(GCC_COMPILER) 2340 UCaux2.v =(vector unsigned char){0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF}; 2341 # elif defined(MAC_COMPILER) || defined (XLC_COMPILER) 2342 UCaux2.v =(vector unsigned char)(0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF); 2343 # endif 2344 for( i=0; i< 16; i++ ) 2345 { 2346 UCaux = UCaux2.e[i]+b; 2347 if (UCaux1.e[i] != UCaux) 2348 err++; 2349 } 2350 if (err) 2351 printf("Function vec_lvsl [type unsigned char] ===> Error\n"); 2352 else 2353 printf("Function vec_lvsl [type unsigned char] ===> OK\n"); 2354 2355 /* Function vec_lvsr */ 2356 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2357 err = 0; 2358 b = 3; 2359 UCaux1.v = vec_lvsr( b, &b); 2360 bAux = b + (size_t)(&b); 2361 b = bAux & 0xF; 2362 # if defined (GCC_COMPILER) 2363 UCaux2.v =(vector unsigned char){0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F}; 2364 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 2365 UCaux2.v =(vector unsigned char)(0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F); 2366 # endif 2367 for( i=0; i< 16; i++ ) 2368 { 2369 UCaux = UCaux2.e[i]-b; 2370 if (UCaux1.e[i] != UCaux) 2371 err++; 2372 } 2373 if (err) 2374 printf("Function vec_lvsr [type unsigned char] ===> Error\n"); 2375 else 2376 printf("Function vec_lvsr [type unsigned char] ===> OK\n"); 2377 2378 #if defined TEST_FLOATS 2379 /* Function vec_madd */ 2380 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2381 err = 0; 2382 Faux1.v = vec_madd( Fcons1, Fcons2, Fcons3 ); 2383 Faux2.v = Fcons1; 2384 Faux3.v = Fcons2; 2385 Faux4.v = Fcons3; 2386 for( i=0; i< 4; i++ ) 2387 if (Faux1.e[i] != (Faux2.e[i]*Faux3.e[i]+Faux4.e[i])) 2388 err++; 2389 if (err) 2390 printf("Function vec_madd [type float] ===> Error\n"); 2391 else 2392 printf("Function vec_madd [type float] ===> OK\n"); 2393 #endif 2394 2395 /* Function vec_madds */ 2396 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2397 err = 0; 2398 Saux1.v = vec_madds( Scons1, Scons3, Scons2 ); 2399 Saux2.v = Scons1; 2400 Saux3.v = Scons3; 2401 Saux4.v = Scons2; 2402 for( i=0; i< 8; i++ ) 2403 { 2404 INTunion1.si = Saux2.e[i]*Saux3.e[i]; 2405 INTunion1.si = INTunion1.si >> 15; 2406 INTunion1.si = INTunion1.si + Saux4.e[i]; 2407 if (INTunion1.si>32767) 2408 Saux=0x7FFF; 2409 else if (INTunion1.si<(-32768)) 2410 Saux=0x8000; 2411 else 2412 Saux= INTunion1.ss[1]; 2413 if (Saux1.e[i] != Saux) 2414 err++; 2415 } 2416 if (err) 2417 printf("Function vec_madds [type short] ===> Error\n"); 2418 else 2419 printf("Function vec_madds [type short] ===> OK\n"); 2420 2421 /* Function vec_max */ 2422 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2423 err = 0; 2424 Caux1.v = vec_max( Ccons1, Ccons2 ); 2425 Caux2.v = Ccons1; 2426 Caux3.v = Ccons2; 2427 for( i=0; i< 16; i++ ) 2428 { 2429 if (Caux2.e[i]>Caux3.e[i]) 2430 Caux = Caux2.e[i]; 2431 else 2432 Caux = Caux3.e[i]; 2433 if (Caux1.e[i] != Caux) 2434 err++; 2435 } 2436 if (err) 2437 printf("Function vec_max [type char] ===> Error\n"); 2438 else 2439 printf("Function vec_max [type char] ===> OK\n"); 2440 2441 err = 0; 2442 UCaux1.v = vec_max( UCcons1, UCcons2 ); 2443 UCaux2.v = UCcons1; 2444 UCaux3.v = UCcons2; 2445 for( i=0; i< 16; i++ ) 2446 { 2447 if (UCaux2.e[i]>UCaux3.e[i]) 2448 UCaux = UCaux2.e[i]; 2449 else 2450 UCaux = UCaux3.e[i]; 2451 if (UCaux1.e[i] != UCaux) 2452 err++; 2453 } 2454 if (err) 2455 printf("Function vec_max [type unsigned char] ===> Error\n"); 2456 else 2457 printf("Function vec_max [type unsigned char] ===> OK\n"); 2458 2459 err = 0; 2460 Saux1.v = vec_max( Scons1, Scons3 ); 2461 Saux2.v = Scons1; 2462 Saux3.v = Scons3; 2463 for( i=0; i< 8; i++ ) 2464 { 2465 if (Saux2.e[i]>Saux3.e[i]) 2466 Saux = Saux2.e[i]; 2467 else 2468 Saux = Saux3.e[i]; 2469 if (Saux1.e[i] != Saux) 2470 err++; 2471 } 2472 if (err) 2473 printf("Function vec_max [type short] ===> Error\n"); 2474 else 2475 printf("Function vec_max [type short] ===> OK\n"); 2476 2477 err = 0; 2478 USaux1.v = vec_max( UScons1, UScons2 ); 2479 USaux2.v = UScons1; 2480 USaux3.v = UScons2; 2481 for( i=0; i< 8; i++ ) 2482 { 2483 if (USaux2.e[i]>USaux3.e[i]) 2484 USaux = USaux2.e[i]; 2485 else 2486 USaux = USaux3.e[i]; 2487 if (USaux1.e[i] != USaux) 2488 err++; 2489 } 2490 if (err) 2491 printf("Function vec_max [type unsigned short] ===> Error\n"); 2492 else 2493 printf("Function vec_max [type unsigned short] ===> OK\n"); 2494 2495 err = 0; 2496 Iaux1.v = vec_max( Icons1, Icons2 ); 2497 Iaux2.v = Icons1; 2498 Iaux3.v = Icons2; 2499 for( i=0; i< 4; i++ ) 2500 { 2501 if (Iaux2.e[i]>Iaux3.e[i]) 2502 Iaux = Iaux2.e[i]; 2503 else 2504 Iaux = Iaux3.e[i]; 2505 if (Iaux1.e[i] != Iaux) 2506 err++; 2507 } 2508 if (err) 2509 printf("Function vec_max [type integer] ===> Error\n"); 2510 else 2511 printf("Function vec_max [type integer] ===> OK\n"); 2512 2513 err = 0; 2514 UIaux1.v = vec_max( UIcons1, UIcons2 ); 2515 UIaux2.v = UIcons1; 2516 UIaux3.v = UIcons2; 2517 for( i=0; i< 4; i++ ) 2518 { 2519 if (UIaux2.e[i]>UIaux3.e[i]) 2520 UIaux = UIaux2.e[i]; 2521 else 2522 UIaux = UIaux3.e[i]; 2523 if (UIaux1.e[i] != UIaux) 2524 err++; 2525 } 2526 if (err) 2527 printf("Function vec_max [type unsigned int] ===> Error\n"); 2528 else 2529 printf("Function vec_max [type unsigned int] ===> OK\n"); 2530 2531 #if defined TEST_FLOATS 2532 err = 0; 2533 Faux1.v = vec_max( Fcons1, Fcons2 ); 2534 Faux2.v = Fcons1; 2535 Faux3.v = Fcons2; 2536 for( i=0; i< 4; i++ ) 2537 { 2538 if (Faux2.e[i]>Faux3.e[i]) 2539 Faux = Faux2.e[i]; 2540 else 2541 Faux = Faux3.e[i]; 2542 if (Faux1.e[i] != Faux) 2543 err++; 2544 } 2545 if (err) 2546 printf("Function vec_max [type float] ===> Error\n"); 2547 else 2548 printf("Function vec_max [type float] ===> OK\n"); 2549 #endif 2550 2551 /* Function vec_mergeh */ 2552 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2553 err = 0; 2554 Caux1.v = vec_mergeh( Ccons1, Ccons2 ); 2555 Caux2.v = Ccons1; 2556 Caux3.v = Ccons2; 2557 for( i=0; i< 8; i++ ) 2558 if ((Caux1.e[2*i] != Caux2.e[i])||(Caux1.e[2*i+1]!=Caux3.e[i])) 2559 err++; 2560 if (err) 2561 printf("Function vec_mergeh [type char] ===> Error\n"); 2562 else 2563 printf("Function vec_mergeh [type char] ===> OK\n"); 2564 2565 err = 0; 2566 UCaux1.v = vec_mergeh( UCcons1, UCcons2 ); 2567 UCaux2.v = UCcons1; 2568 UCaux3.v = UCcons2; 2569 for( i=0; i< 8; i++ ) 2570 if ((UCaux1.e[2*i] != UCaux2.e[i])||(UCaux1.e[2*i+1]!=UCaux3.e[i])) 2571 err++; 2572 if (err) 2573 printf("Function vec_mergeh [type unsigned char] ===> Error\n"); 2574 else 2575 printf("Function vec_mergeh [type unsigned char] ===> OK\n"); 2576 2577 err = 0; 2578 Saux1.v = vec_mergeh( Scons1, Scons2 ); 2579 Saux2.v = Scons1; 2580 Saux3.v = Scons2; 2581 for( i=0; i< 4; i++ ) 2582 if ((Saux1.e[2*i] != Saux2.e[i])||(Saux1.e[2*i+1]!=Saux3.e[i])) 2583 err++; 2584 if (err) 2585 printf("Function vec_mergeh [type short] ===> Error\n"); 2586 else 2587 printf("Function vec_mergeh [type short] ===> OK\n"); 2588 2589 err = 0; 2590 USaux1.v = vec_mergeh( UScons1, UScons2 ); 2591 USaux2.v = UScons1; 2592 USaux3.v = UScons2; 2593 for( i=0; i< 4; i++ ) 2594 if ((USaux1.e[2*i] != USaux2.e[i])||(USaux1.e[2*i+1]!=USaux3.e[i])) 2595 err++; 2596 if (err) 2597 printf("Function vec_mergeh [type unsigned short] ===> Error\n"); 2598 else 2599 printf("Function vec_mergeh [type unsigned short] ===> OK\n"); 2600 2601 err = 0; 2602 Iaux1.v = vec_mergeh( Icons1, Icons2 ); 2603 Iaux2.v = Icons1; 2604 Iaux3.v = Icons2; 2605 for( i=0; i< 2; i++ ) 2606 if ((Iaux1.e[2*i] != Iaux2.e[i])||(Iaux1.e[2*i+1]!=Iaux3.e[i])) 2607 err++; 2608 if (err) 2609 printf("Function vec_mergeh [type integer] ===> Error\n"); 2610 else 2611 printf("Function vec_mergeh [type integer] ===> OK\n"); 2612 2613 err = 0; 2614 UIaux1.v = vec_mergeh( UIcons1, UIcons2 ); 2615 UIaux2.v = UIcons1; 2616 UIaux3.v = UIcons2; 2617 for( i=0; i< 2; i++ ) 2618 if ((UIaux1.e[2*i] != UIaux2.e[i])||(UIaux1.e[2*i+1]!=UIaux3.e[i])) 2619 err++; 2620 if (err) 2621 printf("Function vec_mergeh [type unsigned int] ===> Error\n"); 2622 else 2623 printf("Function vec_mergeh [type unsigned int] ===> OK\n"); 2624 2625 #if defined TEST_FLOATS 2626 err = 0; 2627 Faux1.v = vec_mergeh( Fcons1, Fcons2 ); 2628 Faux2.v = Fcons1; 2629 Faux3.v = Fcons2; 2630 for( i=0; i< 2; i++ ) 2631 if ((Faux1.e[2*i] != Faux2.e[i])||(Faux1.e[2*i+1]!=Faux3.e[i])) 2632 err++; 2633 if (err) 2634 printf("Function vec_mergeh [type float] ===> Error\n"); 2635 else 2636 printf("Function vec_mergeh [type float] ===> OK\n"); 2637 #endif 2638 2639 /* Function vec_mergel */ 2640 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2641 err = 0; 2642 Caux1.v = vec_mergel( Ccons1, Ccons2 ); 2643 Caux2.v = Ccons1; 2644 Caux3.v = Ccons2; 2645 for( i=0; i< 8; i++ ) 2646 if ((Caux1.e[2*i] != Caux2.e[i+8])||(Caux1.e[2*i+1]!=Caux3.e[i+8])) 2647 err++; 2648 if (err) 2649 printf("Function vec_mergel [type char] ===> Error\n"); 2650 else 2651 printf("Function vec_mergel [type char] ===> OK\n"); 2652 2653 err = 0; 2654 UCaux1.v = vec_mergel( UCcons1, UCcons2 ); 2655 UCaux2.v = UCcons1; 2656 UCaux3.v = UCcons2; 2657 for( i=0; i< 8; i++ ) 2658 if ((UCaux1.e[2*i] != UCaux2.e[i+8])||(UCaux1.e[2*i+1]!=UCaux3.e[i+8])) 2659 err++; 2660 if (err) 2661 printf("Function vec_mergel [type unsigned char] ===> Error\n"); 2662 else 2663 printf("Function vec_mergel [type unsigned char] ===> OK\n"); 2664 2665 err = 0; 2666 Saux1.v = vec_mergel( Scons1, Scons2 ); 2667 Saux2.v = Scons1; 2668 Saux3.v = Scons2; 2669 for( i=0; i< 4; i++ ) 2670 if ((Saux1.e[2*i] != Saux2.e[i+4])||(Saux1.e[2*i+1]!=Saux3.e[i+4])) 2671 err++; 2672 if (err) 2673 printf("Function vec_mergel [type short] ===> Error\n"); 2674 else 2675 printf("Function vec_mergel [type short] ===> OK\n"); 2676 2677 err = 0; 2678 USaux1.v = vec_mergel( UScons1, UScons2 ); 2679 USaux2.v = UScons1; 2680 USaux3.v = UScons2; 2681 for( i=0; i< 4; i++ ) 2682 if ((USaux1.e[2*i] != USaux2.e[i+4])||(USaux1.e[2*i+1]!=USaux3.e[i+4])) 2683 err++; 2684 if (err) 2685 printf("Function vec_mergel [type unsigned short] ===> Error\n"); 2686 else 2687 printf("Function vec_mergel [type unsigned short] ===> OK\n"); 2688 2689 err = 0; 2690 Iaux1.v = vec_mergel( Icons1, Icons2 ); 2691 Iaux2.v = Icons1; 2692 Iaux3.v = Icons2; 2693 for( i=0; i< 2; i++ ) 2694 if ((Iaux1.e[2*i] != Iaux2.e[i+2])||(Iaux1.e[2*i+1]!=Iaux3.e[i+2])) 2695 err++; 2696 if (err) 2697 printf("Function vec_mergel [type integer] ===> Error\n"); 2698 else 2699 printf("Function vec_mergel [type integer] ===> OK\n"); 2700 2701 err = 0; 2702 UIaux1.v = vec_mergel( UIcons1, UIcons2 ); 2703 UIaux2.v = UIcons1; 2704 UIaux3.v = UIcons2; 2705 for( i=0; i< 2; i++ ) 2706 if ((UIaux1.e[2*i] != UIaux2.e[i+2])||(UIaux1.e[2*i+1]!=UIaux3.e[i+2])) 2707 err++; 2708 if (err) 2709 printf("Function vec_mergel [type unsigned int] ===> Error\n"); 2710 else 2711 printf("Function vec_mergel [type unsigned int] ===> OK\n"); 2712 2713 #if defined TEST_FLOATS 2714 err = 0; 2715 Faux1.v = vec_mergel( Fcons1, Fcons2 ); 2716 Faux2.v = Fcons1; 2717 Faux3.v = Fcons2; 2718 for( i=0; i< 2; i++ ) 2719 if ((Faux1.e[2*i] != Faux2.e[i+2])||(Faux1.e[2*i+1]!=Faux3.e[i+2])) 2720 err++; 2721 if (err) 2722 printf("Function vec_mergel [type float] ===> Error\n"); 2723 else 2724 printf("Function vec_mergel [type float] ===> OK\n"); 2725 #endif 2726 2727 /* Function vec_mfvscr */ 2728 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2729 printf("Function vec_mfvscr [Vector Move from Vector Status and Control Register] not checked\n"); 2730 2731 /* Function vec_min */ 2732 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2733 #ifndef XLC_COMPILER 2734 err = 0; 2735 Caux1.v = vec_min( Ccons1, Ccons2 ); 2736 Caux2.v = Ccons1; 2737 Caux3.v = Ccons2; 2738 for( i=0; i< 8; i++ ) 2739 { 2740 if (Caux2.e[i]<Caux3.e[i]) 2741 Caux = Caux2.e[i]; 2742 else 2743 Caux = Caux3.e[i]; 2744 if (Caux1.e[i] != Caux) 2745 err++; 2746 } 2747 if (err) 2748 printf("Function vec_min [type char] ===> Error\n"); 2749 else 2750 printf("Function vec_min [type char] ===> OK\n"); 2751 #endif 2752 2753 err = 0; 2754 UCaux1.v = vec_min( UCcons1, UCcons2 ); 2755 UCaux2.v = UCcons1; 2756 UCaux3.v = UCcons2; 2757 for( i=0; i< 8; i++ ) 2758 { 2759 if (UCaux2.e[i]<UCaux3.e[i]) 2760 UCaux = UCaux2.e[i]; 2761 else 2762 UCaux = UCaux3.e[i]; 2763 if (UCaux1.e[i] != UCaux) 2764 err++; 2765 } 2766 if (err) 2767 printf("Function vec_min [type unsigned char] ===> Error\n"); 2768 else 2769 printf("Function vec_min [type unsigned char] ===> OK\n"); 2770 2771 #ifndef XLC_COMPILER 2772 err = 0; 2773 Saux1.v = vec_min( Scons1, Scons2 ); 2774 Saux2.v = Scons1; 2775 Saux3.v = Scons2; 2776 for( i=0; i< 8; i++ ) 2777 { 2778 if (Saux2.e[i]<Saux3.e[i]) 2779 Saux = Saux2.e[i]; 2780 else 2781 Saux = Saux3.e[i]; 2782 if (Saux1.e[i] != Saux) 2783 err++; 2784 } 2785 if (err) 2786 printf("Function vec_min [type short] ===> Error\n"); 2787 else 2788 printf("Function vec_min [type short] ===> OK\n"); 2789 2790 err = 0; 2791 USaux1.v = vec_min( UScons1, UScons2 ); 2792 USaux2.v = UScons1; 2793 USaux3.v = UScons2; 2794 for( i=0; i< 8; i++ ) 2795 { 2796 if (USaux2.e[i]<USaux3.e[i]) 2797 USaux = USaux2.e[i]; 2798 else 2799 USaux = USaux3.e[i]; 2800 if (USaux1.e[i] != USaux) 2801 err++; 2802 } 2803 if (err) 2804 printf("Function vec_min [type unsigned short] ===> Error\n"); 2805 else 2806 printf("Function vec_min [type unsigned short] ===> OK\n"); 2807 2808 err = 0; 2809 Iaux1.v = vec_min( Icons1, Icons2 ); 2810 Iaux2.v = Icons1; 2811 Iaux3.v = Icons2; 2812 for( i=0; i< 4; i++ ) 2813 { 2814 if (Iaux2.e[i]<Iaux3.e[i]) 2815 Iaux = Iaux2.e[i]; 2816 else 2817 Iaux = Iaux3.e[i]; 2818 if (Iaux1.e[i] != Iaux) 2819 err++; 2820 } 2821 if (err) 2822 printf("Function vec_min [type integer] ===> Error\n"); 2823 else 2824 printf("Function vec_min [type integer] ===> OK\n"); 2825 2826 err = 0; 2827 UIaux1.v = vec_min( UIcons1, UIcons2 ); 2828 UIaux2.v = UIcons1; 2829 UIaux3.v = UIcons2; 2830 for( i=0; i< 4; i++ ) 2831 { 2832 if (UIaux2.e[i]<UIaux3.e[i]) 2833 UIaux = UIaux2.e[i]; 2834 else 2835 UIaux = UIaux3.e[i]; 2836 if (UIaux1.e[i] != UIaux) 2837 err++; 2838 } 2839 if (err) 2840 printf("Function vec_min [type unsigned int] ===> Error\n"); 2841 else 2842 printf("Function vec_min [type unsigned int] ===> OK\n"); 2843 2844 #if defined TEST_FLOATS 2845 err = 0; 2846 Faux1.v = vec_min( Fcons1, Fcons2 ); 2847 Faux2.v = Fcons1; 2848 Faux3.v = Fcons2; 2849 for( i=0; i< 4; i++ ) 2850 { 2851 if (Faux2.e[i]<Faux3.e[i]) 2852 Faux = Faux2.e[i]; 2853 else 2854 Faux = Faux3.e[i]; 2855 if (Faux1.e[i] != Faux) 2856 err++; 2857 } 2858 if (err) 2859 printf("Function vec_min [type float] ===> Error\n"); 2860 else 2861 printf("Function vec_min [type float] ===> OK\n"); 2862 #endif 2863 2864 #endif 2865 2866 /* Function vec_mladd */ 2867 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2868 #ifndef XLC_COMPILER 2869 err = 0; 2870 Saux1.v = vec_mladd( Scons1, Scons2, Scons3 ); 2871 Saux2.v = Scons1; 2872 Saux3.v = Scons2; 2873 Saux4.v = Scons3; 2874 for( i=0; i< 8; i++ ) 2875 { 2876 INTunion1.si = Saux2.e[i]*Saux3.e[i]; 2877 INTunion1.si = INTunion1.si + Saux4.e[i]; 2878 if (Saux1.e[i] != INTunion1.ss[1]) 2879 err++; 2880 } 2881 if (err) 2882 printf("Function vec_mladd [type short] ===> Error\n"); 2883 else 2884 printf("Function vec_mladd [type short] ===> OK\n"); 2885 #endif 2886 2887 err = 0; 2888 USaux1.v = vec_mladd( UScons1, UScons2, UScons3 ); 2889 USaux2.v = UScons1; 2890 USaux3.v = UScons2; 2891 USaux4.v = UScons3; 2892 for( i=0; i< 8; i++ ) 2893 { 2894 INTunion1.ui = USaux2.e[i]*USaux3.e[i]; 2895 INTunion1.ui = INTunion1.ui + USaux4.e[i]; 2896 if (USaux1.e[i] != INTunion1.us[1]) 2897 err++; 2898 } 2899 if (err) 2900 printf("Function vec_mladd [type unsigned short] ===> Error\n"); 2901 else 2902 printf("Function vec_mladd [type unsigned short] ===> OK\n"); 2903 2904 /* Function vec_mradds */ 2905 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2906 err = 0; 2907 Saux1.v = vec_mradds( Scons1, Scons2, Scons3 ); 2908 Saux2.v = Scons1; 2909 Saux3.v = Scons2; 2910 Saux4.v = Scons3; 2911 for( i=0; i< 8; i++ ) 2912 { 2913 INTunion1.si = Saux2.e[i]*Saux3.e[i]+0x4000; 2914 INTunion1.si = INTunion1.si >> 15; 2915 INTunion1.si = INTunion1.si + Saux4.e[i]; 2916 if (INTunion1.si>32767) 2917 Saux = 0x7FFF; 2918 else if (INTunion1.si<(-32768)) 2919 Saux = 0x8000; 2920 else 2921 Saux = INTunion1.ss[1]; 2922 if (Saux1.e[i] != Saux) 2923 err++; 2924 2925 printf("vector: %d \n", Saux1.e[i]); 2926 printf("scalar: %d \n", Saux); 2927 } 2928 2929 if (err) 2930 printf("Function vec_mradds [type short] ===> Error\n"); 2931 else 2932 printf("Function vec_mradds [type short] ===> OK\n"); 2933 2934 /* Function vec_msum */ 2935 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 2936 #ifndef XLC_COMPILER 2937 err = 0; 2938 Iaux1.v = vec_msum( Ccons1, UCcons2, Icons1 ); 2939 Caux1.v = Ccons1; 2940 UCaux1.v = UCcons2; 2941 Iaux2.v = Icons1; 2942 for( i=0; i< 4; i++ ) 2943 { 2944 Iaux = Iaux2.e[i]; 2945 for (j=0; j< 4; j++) 2946 Iaux = Iaux + Caux1.e[4*i+j]*UCaux1.e[4*i+j]; 2947 if (Iaux1.e[i] != Iaux) 2948 err++; 2949 } 2950 if (err) 2951 printf("Function vec_msum [type char] ===> Error\n"); 2952 else 2953 printf("Function vec_msum [type char] ===> OK\n"); 2954 #endif 2955 2956 err = 0; 2957 UIaux1.v = vec_msum( UCcons1, UCcons2, UIcons1 ); 2958 UCaux1.v = UCcons1; 2959 UCaux2.v = UCcons2; 2960 UIaux2.v = UIcons1; 2961 for( i=0; i< 4; i++ ) 2962 { 2963 UIaux = UIaux2.e[i]; 2964 for (j=0; j< 4; j++) 2965 UIaux = UIaux + UCaux1.e[4*i+j]*UCaux2.e[4*i+j]; 2966 if (UIaux1.e[i] != UIaux) 2967 err++; 2968 } 2969 if (err) 2970 printf("Function vec_msum [type unsigned char] ===> Error\n"); 2971 else 2972 printf("Function vec_msum [type unsigned char] ===> OK\n"); 2973 2974 #ifndef XLC_COMPILER 2975 err = 0; 2976 Iaux1.v = vec_msum( Scons1, Scons2, Icons1 ); 2977 Saux1.v = Scons1; 2978 Saux2.v = Scons2; 2979 Iaux2.v = Icons1; 2980 for( i=0; i< 4; i++ ) 2981 { 2982 Iaux = Iaux2.e[i]; 2983 for (j=0; j< 2; j++) 2984 Iaux = Iaux + Saux1.e[2*i+j]*Saux2.e[2*i+j]; 2985 if (Iaux1.e[i] != Iaux) 2986 err++; 2987 } 2988 if (err) 2989 printf("Function vec_msum [type short] ===> Error\n"); 2990 else 2991 printf("Function vec_msum [type short] ===> OK\n"); 2992 2993 err = 0; 2994 UIaux1.v = vec_msum( UScons1, UScons2, UIcons1 ); 2995 USaux1.v = UScons1; 2996 USaux2.v = UScons2; 2997 UIaux2.v = UIcons1; 2998 for( i=0; i< 4; i++ ) 2999 { 3000 UIaux = UIaux2.e[i]; 3001 for (j=0; j< 2; j++) 3002 UIaux = UIaux + USaux1.e[2*i+j]*USaux2.e[2*i+j]; 3003 if (UIaux1.e[i] != UIaux) 3004 err++; 3005 } 3006 if (err) 3007 printf("Function vec_msum [type unsigned short] ===> Error\n"); 3008 else 3009 printf("Function vec_msum [type unsigned short] ===> OK\n"); 3010 #endif 3011 3012 /* Function vec_msums */ 3013 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3014 err = 0; 3015 Iaux1.v = vec_msums( Scons2, Scons3, Icons3 ); 3016 Saux1.v = Scons2; 3017 Saux2.v = Scons3; 3018 Iaux2.v = Icons3; 3019 for( i=0; i< 4; i++ ) 3020 { 3021 I1 = Saux1.e[2*i]*Saux2.e[2*i]; 3022 I2 = Saux1.e[2*i+1]*Saux2.e[2*i+1]; 3023 Iaux = I1 + I2; 3024 if ((I1>0)&&(I2>0)&&(Iaux<0)) 3025 Iaux=0x7FFFFFFF; 3026 else if ((I1<0)&&(I2<0)&&(Iaux>0)) 3027 Iaux=0x80000000; 3028 I1 = Iaux2.e[i]; 3029 I2 = Iaux; 3030 Iaux = I1 + I2; 3031 if ((I1>0)&&(I2>0)&&(Iaux<0)) 3032 Iaux=0x7FFFFFFF; 3033 else if ((I1<0)&&(I2<0)&&(Iaux>0)) 3034 Iaux=0x80000000; 3035 if (Iaux1.e[i] != Iaux) 3036 err++; 3037 } 3038 if (err) 3039 printf("Function vec_msums [type short] ===> Error\n"); 3040 else 3041 printf("Function vec_msums [type short] ===> OK\n"); 3042 3043 err = 0; 3044 UIaux1.v = vec_msums( UScons2, UScons3, UIcons3 ); 3045 USaux1.v = UScons2; 3046 USaux2.v = UScons3; 3047 UIaux2.v = UIcons3; 3048 for( i=0; i< 4; i++ ) 3049 { 3050 UI1 = USaux1.e[2*i]*USaux2.e[2*i]; 3051 UI2 = USaux1.e[2*i+1]*USaux2.e[2*i+1]; 3052 UIaux = UI1 + UI2; 3053 if ((UIaux<UI1)||(UIaux<UI2)) 3054 UIaux=0xFFFFFFFF; 3055 UI1 = UIaux2.e[i]; 3056 UI2 = UIaux; 3057 UIaux = UI1 + UI2; 3058 if ((UIaux<UI1)||(UIaux<UI2)) 3059 UIaux=0xFFFFFFFF; 3060 if (UIaux1.e[i] != UIaux) 3061 err++; 3062 } 3063 if (err) 3064 printf("Function vec_msums [type unsigned short] ===> Error\n"); 3065 else 3066 printf("Function vec_msums [type unsigned short] ===> OK\n"); 3067 3068 /* Function vec_mtvscr */ 3069 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3070 printf("Function vec_mtvscr [Vector Move to Vector Status and Control Register] not checked\n"); 3071 3072 /* Function vec_mule */ 3073 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3074 err = 0; 3075 Saux1.v = vec_mule( Ccons1, Ccons2 ); 3076 Caux1.v = Ccons1; 3077 Caux2.v = Ccons2; 3078 for( i=0; i< 4; i++ ) 3079 if (Saux1.e[i] != (Caux1.e[2*i]*Caux2.e[2*i])) 3080 err++; 3081 if (err) 3082 printf("Function vec_mule [type char] ===> Error\n"); 3083 else 3084 printf("Function vec_mule [type char] ===> OK\n"); 3085 3086 err = 0; 3087 USaux1.v = vec_mule( UCcons1, UCcons2 ); 3088 UCaux1.v = UCcons1; 3089 UCaux2.v = UCcons2; 3090 for( i=0; i< 4; i++ ) 3091 if (USaux1.e[i] != (UCaux1.e[2*i]*UCaux2.e[2*i])) 3092 err++; 3093 if (err) 3094 printf("Function vec_mule [type unsigned char] ===> Error\n"); 3095 else 3096 printf("Function vec_mule [type unsigned char] ===> OK\n"); 3097 3098 err = 0; 3099 Iaux1.v = vec_mule( Scons1, Scons2 ); 3100 Saux1.v = Scons1; 3101 Saux2.v = Scons2; 3102 for( i=0; i< 4; i++ ) 3103 if (Iaux1.e[i] != (Saux1.e[2*i]*Saux2.e[2*i])) 3104 err++; 3105 if (err) 3106 printf("Function vec_mule [type short] ===> Error\n"); 3107 else 3108 printf("Function vec_mule [type short] ===> OK\n"); 3109 3110 err = 0; 3111 UIaux1.v = vec_mule( UScons1, UScons2 ); 3112 USaux1.v = UScons1; 3113 USaux2.v = UScons2; 3114 for( i=0; i< 4; i++ ) 3115 if (UIaux1.e[i] != (USaux1.e[2*i] * USaux2.e[2*i])) 3116 err++; 3117 if (err) 3118 printf("Function vec_mule [type unsigned short] ===> Error\n"); 3119 else 3120 printf("Function vec_mule [type unsigned short] ===> OK\n"); 3121 3122 /* Function vec_mulo */ 3123 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3124 err = 0; 3125 Saux1.v = vec_mulo( Ccons1, Ccons2 ); 3126 Caux1.v = Ccons1; 3127 Caux2.v = Ccons2; 3128 for( i=0; i< 4; i++ ) 3129 if (Saux1.e[i] != (Caux1.e[2*i+1]*Caux2.e[2*i+1])) 3130 err++; 3131 if (err) 3132 printf("Function vec_mulo [type char] ===> Error\n"); 3133 else 3134 printf("Function vec_mulo [type char] ===> OK\n"); 3135 3136 err = 0; 3137 USaux1.v = vec_mulo( UCcons1, UCcons2 ); 3138 UCaux1.v = UCcons1; 3139 UCaux2.v = UCcons2; 3140 for( i=0; i< 4; i++ ) 3141 if (USaux1.e[i] != (UCaux1.e[2*i+1]*UCaux2.e[2*i+1])) 3142 err++; 3143 if (err) 3144 printf("Function vec_mulo [type unsigned char] ===> Error\n"); 3145 else 3146 printf("Function vec_mulo [type unsigned char] ===> OK\n"); 3147 3148 err = 0; 3149 Iaux1.v = vec_mulo( Scons1, Scons2 ); 3150 Saux1.v = Scons1; 3151 Saux2.v = Scons2; 3152 for( i=0; i< 4; i++ ) 3153 if (Iaux1.e[i] != (Saux1.e[2*i+1]*Saux2.e[2*i+1])) 3154 err++; 3155 if (err) 3156 printf("Function vec_mulo [type short] ===> Error\n"); 3157 else 3158 printf("Function vec_mulo [type short] ===> OK\n"); 3159 3160 err = 0; 3161 UIaux1.v = vec_mulo( UScons1, UScons2 ); 3162 USaux1.v = UScons1; 3163 USaux2.v = UScons2; 3164 for( i=0; i< 4; i++ ) 3165 if (UIaux1.e[i] != (USaux1.e[2*i+1]*USaux2.e[2*i+1])) 3166 err++; 3167 if (err) 3168 printf("Function vec_mulo [type unsigned short] ===> Error\n"); 3169 else 3170 printf("Function vec_mulo [type unsigned short] ===> OK\n"); 3171 3172 #if defined TEST_FLOATS 3173 /* Function vec_nmsub */ 3174 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3175 err = 0; 3176 Faux1.v = vec_nmsub( Fcons1, Fcons2, Fcons3 ); 3177 Faux2.v = Fcons1; 3178 Faux3.v = Fcons2; 3179 Faux4.v = Fcons3; 3180 for( i=0; i< 4; i++ ) 3181 { 3182 if (Faux1.e[i] != (-Faux2.e[i]*Faux3.e[i]+Faux4.e[i])) 3183 err++; 3184 } 3185 if (err) 3186 printf("Function vec_nmsub [type float] ===> Error\n"); 3187 else 3188 printf("Function vec_nmsub [type float] ===> OK\n"); 3189 #endif 3190 3191 /* Function vec_nor */ 3192 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3193 err = 0; 3194 Caux1.v = vec_nor( Ccons1, Ccons2 ); 3195 Caux2.v = Ccons1; 3196 Caux3.v = Ccons2; 3197 for( i=0; i< 16; i++ ) 3198 if (Caux1.e[i] != ~(Caux2.e[i] | Caux3.e[i])) 3199 err++; 3200 if (err) 3201 printf("Function vec_nor [type char] ===> Error\n"); 3202 else 3203 printf("Function vec_nor [type char] ===> OK\n"); 3204 3205 err = 0; 3206 UCaux1.v = vec_nor( UCcons1, UCcons2 ); 3207 UCaux2.v = UCcons1; 3208 UCaux3.v = UCcons2; 3209 for( i=0; i< 16; i++ ) 3210 { 3211 UCaux = UCaux2.e[i] | UCaux3.e[i]; 3212 UCaux = ~UCaux; 3213 if (UCaux1.e[i] != UCaux ) 3214 err++; 3215 } 3216 if (err) 3217 printf("Function vec_nor [type unsigened char] ===> Error\n"); 3218 else 3219 printf("Function vec_nor [type unsigened char] ===> OK\n"); 3220 3221 err = 0; 3222 Saux1.v = vec_nor( Scons1, Scons2 ); 3223 Saux2.v = Scons1; 3224 Saux3.v = Scons2; 3225 for( i=0; i< 8; i++ ) 3226 if (Saux1.e[i] != ~(Saux2.e[i] | Saux3.e[i])) 3227 err++; 3228 if (err) 3229 printf("Function vec_nor [type short] ===> Error\n"); 3230 else 3231 printf("Function vec_nor [type short] ===> OK\n"); 3232 3233 err = 0; 3234 USaux1.v = vec_nor( UScons1, UScons2 ); 3235 USaux2.v = UScons1; 3236 USaux3.v = UScons2; 3237 for( i=0; i< 8; i++ ) 3238 { 3239 USaux = USaux2.e[i] | USaux3.e[i]; 3240 USaux = ~USaux; 3241 if (USaux1.e[i] != USaux ) 3242 err++; 3243 } 3244 if (err) 3245 printf("Function vec_nor [type unsigned short] ===> Error\n"); 3246 else 3247 printf("Function vec_nor [type unsigned short] ===> OK\n"); 3248 3249 err = 0; 3250 Iaux1.v = vec_nor( Icons1, Icons2 ); 3251 Iaux2.v = Icons1; 3252 Iaux3.v = Icons2; 3253 for( i=0; i< 4; i++ ) 3254 if (Iaux1.e[i] != ~(Iaux2.e[i] | Iaux3.e[i])) 3255 err++; 3256 if (err) 3257 printf("Function vec_nor [type integer] ===> Error\n"); 3258 else 3259 printf("Function vec_nor [type integer] ===> OK\n"); 3260 3261 err = 0; 3262 UIaux1.v = vec_nor( UIcons1, UIcons2 ); 3263 UIaux2.v = UIcons1; 3264 UIaux3.v = UIcons2; 3265 for( i=0; i< 4; i++ ) 3266 if (UIaux1.e[i] != ~(UIaux2.e[i] | UIaux3.e[i])) 3267 err++; 3268 if (err) 3269 printf("Function vec_nor [type unsigened int] ===> Error\n"); 3270 else 3271 printf("Function vec_nor [type unsigened int] ===> OK\n"); 3272 3273 #if defined TEST_FLOATS 3274 err = 0; 3275 Faux1.v = vec_nor( Fcons1, Fcons2 ); 3276 Faux2.v = Fcons1; 3277 Faux3.v = Fcons2; 3278 for( i=0; i< 4; i++ ) 3279 { 3280 Ivec1 = Faux1.i[i]; 3281 Ivec2 = Faux2.i[i]; 3282 Ivec3 = Faux3.i[i]; 3283 if ((Ivec1) != ~((Ivec2) | (Ivec3))) 3284 err++; 3285 } 3286 if (err) 3287 printf("Function vec_nor [type float] ===> Error\n"); 3288 else 3289 printf("Function vec_nor [type float] ===> OK\n"); 3290 #endif 3291 3292 /* Function vec_or */ 3293 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3294 err = 0; 3295 Caux1.v = vec_or( Ccons1, Ccons2 ); 3296 Caux2.v = Ccons1; 3297 Caux3.v = Ccons2; 3298 for( i=0; i< 16; i++ ) 3299 if (Caux1.e[i] != (Caux2.e[i] | Caux3.e[i])) 3300 err++; 3301 if (err) 3302 printf("Function vec_or [type char] ===> Error\n"); 3303 else 3304 printf("Function vec_or [type char] ===> OK\n"); 3305 3306 err = 0; 3307 UCaux1.v = vec_or( UCcons1, UCcons2 ); 3308 UCaux2.v = UCcons1; 3309 UCaux3.v = UCcons2; 3310 for( i=0; i< 16; i++ ) 3311 { 3312 UCaux = UCaux2.e[i] | UCaux3.e[i]; 3313 if (UCaux1.e[i] != UCaux ) 3314 err++; 3315 } 3316 if (err) 3317 printf("Function vec_or [type unsigened char] ===> Error\n"); 3318 else 3319 printf("Function vec_or [type unsigened char] ===> OK\n"); 3320 3321 err = 0; 3322 Saux1.v = vec_or( Scons1, Scons2 ); 3323 Saux2.v = Scons1; 3324 Saux3.v = Scons2; 3325 for( i=0; i< 8; i++ ) 3326 if (Saux1.e[i] != (Saux2.e[i] | Saux3.e[i])) 3327 err++; 3328 if (err) 3329 printf("Function vec_or [type short] ===> Error\n"); 3330 else 3331 printf("Function vec_or [type short] ===> OK\n"); 3332 3333 err = 0; 3334 USaux1.v = vec_or( UScons1, UScons2 ); 3335 USaux2.v = UScons1; 3336 USaux3.v = UScons2; 3337 for( i=0; i< 8; i++ ) 3338 { 3339 USaux = USaux2.e[i] | USaux3.e[i]; 3340 if (USaux1.e[i] != USaux ) 3341 err++; 3342 } 3343 if (err) 3344 printf("Function vec_or [type unsigned short] ===> Error\n"); 3345 else 3346 printf("Function vec_or [type unsigned short] ===> OK\n"); 3347 3348 err = 0; 3349 Iaux1.v = vec_or( Icons1, Icons2 ); 3350 Iaux2.v = Icons1; 3351 Iaux3.v = Icons2; 3352 for( i=0; i< 4; i++ ) 3353 if (Iaux1.e[i] != (Iaux2.e[i] | Iaux3.e[i])) 3354 err++; 3355 if (err) 3356 printf("Function vec_or [type integer] ===> Error\n"); 3357 else 3358 printf("Function vec_or [type integer] ===> OK\n"); 3359 3360 err = 0; 3361 UIaux1.v = vec_or( UIcons1, UIcons2 ); 3362 UIaux2.v = UIcons1; 3363 UIaux3.v = UIcons2; 3364 for( i=0; i< 4; i++ ) 3365 if (UIaux1.e[i] != (UIaux2.e[i] | UIaux3.e[i])) 3366 err++; 3367 if (err) 3368 printf("Function vec_or [type unsigened int] ===> Error\n"); 3369 else 3370 printf("Function vec_or [type unsigened int] ===> OK\n"); 3371 3372 #if defined TEST_FLOATS 3373 err = 0; 3374 Faux1.v = vec_or( Fcons1, Fcons2 ); 3375 Faux2.v = Fcons1; 3376 Faux3.v = Fcons2; 3377 for( i=0; i< 4; i++ ) 3378 { 3379 Ivec1 = Faux1.i[i]; 3380 Ivec2 = Faux2.i[i]; 3381 Ivec3 = Faux3.i[i]; 3382 if ((Ivec1) != ((Ivec2) | (Ivec3))) 3383 err++; 3384 } 3385 if (err) 3386 printf("Function vec_or [type float] ===> Error\n"); 3387 else 3388 printf("Function vec_or [type float] ===> OK\n"); 3389 #endif 3390 3391 return 0; 3392 } 3393 3394 3395 3396 3397 int part3( ) 3398 { 3399 TvecChar Caux1, Caux2, Caux3;//, Caux4; 3400 TvecUChar UCaux1, UCaux2, UCaux3, UCaux4; 3401 TvecShort Saux1, Saux2, Saux3;//, Saux4; 3402 TvecUShort USaux1, USaux2, USaux3, USaux4; 3403 TvecInt Iaux1, Iaux2, Iaux3;//, Iaux4; 3404 TvecUInt UIaux1, UIaux2, UIaux3, UIaux4; 3405 #if defined TEST_FLOATS 3406 TvecFloat Faux1, Faux2, Faux3;//, Faux4; 3407 #endif 3408 3409 int i, err, /*j,*/ b;//, bAux; 3410 #if defined TEST_FLOATS 3411 signed int Ivec1, Ivec2;//, Ivec3; 3412 #endif 3413 // signed short *Svec1; 3414 unsigned int *UIvec1; 3415 unsigned short *USvec1; 3416 unsigned char *UCvec1; 3417 #if defined TEST_FLOATS 3418 // float *Fvec1; 3419 #endif 3420 3421 /* For saturated rutines */ 3422 // long long int LLaux; 3423 3424 #if defined TEST_FLOATS 3425 float Faux; 3426 #endif 3427 signed int Iaux;//, I1, I2; 3428 unsigned int UIaux;//, UI1, UI2; 3429 signed short Saux; 3430 unsigned short USaux; 3431 signed char Caux; 3432 unsigned char UCaux; 3433 3434 union 3435 { 3436 float f; 3437 signed int si; 3438 unsigned int ui; 3439 signed short ss[2]; 3440 unsigned short us[2]; 3441 signed char sc[4]; 3442 unsigned char uc[4]; 3443 } INTunion1, INTunion2; 3444 3445 union 3446 { 3447 signed short ss; 3448 unsigned short us; 3449 signed char sc[2]; 3450 unsigned char uc[2]; 3451 } SHOunion1, SHOunion2; 3452 3453 3454 #if defined (GCC_COMPILER) 3455 vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 3456 vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 3457 vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127}; 3458 vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7}; 3459 vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; 3460 vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}; 3461 vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3}; 3462 vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000}; 3463 vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767}; 3464 vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3}; 3465 vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1}; 3466 vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4}; 3467 vector signed int Icons1 = (vector signed int){-4, -1, 1, 4}; 3468 vector signed int Icons2 = (vector signed int){1, 1, 1, 1}; 3469 vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF}; 3470 vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1}; 3471 vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1}; 3472 vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2}; 3473 3474 #if defined TEST_FLOATS 3475 vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999}; 3476 vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0}; 3477 vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0}; 3478 #endif 3479 3480 #elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 3481 vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 3482 vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); 3483 vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127); 3484 vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7); 3485 vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2); 3486 vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8); 3487 vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3); 3488 vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000); 3489 vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767); 3490 vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3); 3491 vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1); 3492 vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4); 3493 vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4); 3494 vector signed int Icons2 = (vector signed int)(1, 1, 1, 1); 3495 vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF); 3496 vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1); 3497 vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1); 3498 vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2); 3499 3500 #if defined TEST_FLOATS 3501 vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999); 3502 vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0); 3503 vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0); 3504 #endif 3505 3506 #endif 3507 3508 3509 /* Variables to be allocated with calloc_vec (16 bytes aligned) */ 3510 unsigned char *UCmem = (unsigned char*)calloc_vec( 1, sizeof(vector unsigned char) ); 3511 signed char *Cmem = (signed char*)calloc_vec( 1, sizeof(vector signed char) ); 3512 unsigned short *USmem = (unsigned short*)calloc_vec( 1, sizeof(vector unsigned short) ); 3513 signed short *Smem = (signed short*)calloc_vec( 1, sizeof(vector signed short) ); 3514 unsigned int *UImem = (unsigned int*)calloc_vec( 1, sizeof(vector unsigned int) ); 3515 signed int *Imem = (signed int*)calloc_vec( 1, sizeof(vector signed int) ); 3516 #if defined TEST_FLOATS 3517 float *Fmem = (float*)calloc_vec( 1, sizeof(vector float) ); 3518 #endif 3519 3520 /* Function vec_pack */ 3521 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3522 err = 0; 3523 Caux1.v = vec_pack( Scons1, Scons2 ); 3524 Saux1.v = Scons1; 3525 Saux2.v = Scons2; 3526 for( i=0; i< 8; i++ ) 3527 { 3528 SHOunion1.ss = Saux1.e[i]; 3529 if (Caux1.e[i] != SHOunion1.sc[1]) 3530 err++; 3531 SHOunion1.ss = Saux2.e[i]; 3532 if (Caux1.e[i+8] != SHOunion1.sc[1]) 3533 err++; 3534 } 3535 if (err) 3536 printf("Function vec_pack [type char] ===> Error\n"); 3537 else 3538 printf("Function vec_pack [type char] ===> OK\n"); 3539 3540 err = 0; 3541 UCaux1.v = vec_pack( UScons1, UScons2 ); 3542 USaux1.v = UScons1; 3543 USaux2.v = UScons2; 3544 for( i=0; i< 8; i++ ) 3545 { 3546 SHOunion1.ss = USaux1.e[i]; 3547 if (UCaux1.e[i] != SHOunion1.uc[1]) 3548 err++; 3549 SHOunion1.ss = USaux2.e[i]; 3550 if (UCaux1.e[i+8] != SHOunion1.uc[1]) 3551 err++; 3552 } 3553 if (err) 3554 printf("Function vec_pack [type unsigned char] ===> Error\n"); 3555 else 3556 printf("Function vec_pack [type unsigned char] ===> OK\n"); 3557 3558 err = 0; 3559 Saux1.v = vec_pack( Icons1, Icons2 ); 3560 Iaux1.v = Icons1; 3561 Iaux2.v = Icons2; 3562 for( i=0; i< 4; i++ ) 3563 { 3564 INTunion1.si = Iaux1.e[i]; 3565 if (Saux1.e[i] != INTunion1.ss[1]) 3566 err++; 3567 INTunion1.si = Iaux2.e[i]; 3568 if (Saux1.e[i+4] != INTunion1.ss[1]) 3569 err++; 3570 } 3571 if (err) 3572 printf("Function vec_pack [type short] ===> Error\n"); 3573 else 3574 printf("Function vec_pack [type short] ===> OK\n"); 3575 3576 err = 0; 3577 USaux1.v = vec_pack( UIcons1, UIcons2 ); 3578 UIaux1.v = UIcons1; 3579 UIaux2.v = UIcons2; 3580 for( i=0; i< 4; i++ ) 3581 { 3582 INTunion1.ui = UIaux1.e[i]; 3583 if (USaux1.e[i] != INTunion1.us[1]) 3584 err++; 3585 INTunion1.ui = UIaux2.e[i]; 3586 if (USaux1.e[i+4] != INTunion1.us[1]) 3587 err++; 3588 } 3589 if (err) 3590 printf("Function vec_pack [type unsigned short] ===> Error\n"); 3591 else 3592 printf("Function vec_pack [type unsigned short] ===> OK\n"); 3593 3594 /* Function vec_packpx */ 3595 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3596 printf("Function vec_packpx [Vector Pack Pixel] not checked\n"); 3597 3598 /* Function vec_packs */ 3599 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3600 err = 0; 3601 Caux1.v = vec_packs( Scons1, Scons2 ); 3602 Saux1.v = Scons1; 3603 Saux2.v = Scons2; 3604 for( i=0; i< 8; i++ ) 3605 { 3606 if (Saux1.e[i]>127) 3607 Caux = 127; 3608 else if (Saux1.e[i]<(-128)) 3609 Caux = -128; 3610 else 3611 Caux = (signed char)Saux1.e[i]; 3612 if (Caux1.e[i] != Caux) 3613 err++; 3614 if (Saux2.e[i]>127) 3615 Caux = 127; 3616 else if (Saux2.e[i]<(-128)) 3617 Caux = -128; 3618 else 3619 Caux = (signed char)Saux2.e[i]; 3620 if (Caux1.e[i+8] != Caux) 3621 err++; 3622 } 3623 if (err) 3624 printf("Function vec_packs [type char] ===> Error\n"); 3625 else 3626 printf("Function vec_packs [type char] ===> OK\n"); 3627 3628 err = 0; 3629 UCaux1.v = vec_packs( UScons1, UScons2 ); 3630 USaux1.v = UScons1; 3631 USaux2.v = UScons2; 3632 for( i=0; i< 8; i++ ) 3633 { 3634 if (USaux1.e[i]>255) 3635 UCaux = 255; 3636 else 3637 UCaux = (unsigned char)USaux1.e[i]; 3638 if (UCaux1.e[i] != UCaux) 3639 err++; 3640 if (USaux2.e[i]>255) 3641 UCaux = 255; 3642 else 3643 UCaux = (unsigned char)USaux2.e[i]; 3644 if (UCaux1.e[i+8] != UCaux) 3645 err++; 3646 } 3647 if (err) 3648 printf("Function vec_packs [type unsigned char] ===> Error\n"); 3649 else 3650 printf("Function vec_packs [type unsigned char] ===> OK\n"); 3651 3652 err = 0; 3653 Saux1.v = vec_packs( Icons1, Icons2 ); 3654 Iaux1.v = Icons1; 3655 Iaux2.v = Icons2; 3656 for( i=0; i< 4; i++ ) 3657 { 3658 if (Iaux1.e[i]>32767) 3659 Saux = 32767; 3660 else if (Iaux1.e[i]<(-32768)) 3661 Saux = -32768; 3662 else 3663 Saux = (signed char)Iaux1.e[i]; 3664 if (Saux1.e[i] != Saux) 3665 err++; 3666 if (Iaux2.e[i]>32767) 3667 Saux = 32767; 3668 else if (Iaux2.e[i]<(-32768)) 3669 Saux = -32768; 3670 else 3671 Saux = (signed char)Iaux2.e[i]; 3672 if (Saux1.e[i+4] != Saux) 3673 err++; 3674 } 3675 if (err) 3676 printf("Function vec_packs [type short] ===> Error\n"); 3677 else 3678 printf("Function vec_packs [type short] ===> OK\n"); 3679 3680 err = 0; 3681 USaux1.v = vec_packs( UIcons1, UIcons2 ); 3682 UIaux1.v = UIcons1; 3683 UIaux2.v = UIcons2; 3684 for( i=0; i< 4; i++ ) 3685 { 3686 if (UIaux1.e[i]>65535) 3687 USaux = 65535; 3688 else 3689 USaux = (unsigned char)UIaux1.e[i]; 3690 if (USaux1.e[i] != USaux) 3691 err++; 3692 if (UIaux2.e[i]>65535) 3693 USaux = 65535; 3694 else 3695 USaux = (unsigned char)UIaux2.e[i]; 3696 if (USaux1.e[i+4] != USaux) 3697 err++; 3698 } 3699 if (err) 3700 printf("Function vec_packs [type unsigned short] ===> Error\n"); 3701 else 3702 printf("Function vec_packs [type unsigned short] ===> OK\n"); 3703 3704 /* Function vec_packsu */ 3705 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3706 err = 0; 3707 UCaux1.v = vec_packsu( Scons1, Scons2 ); 3708 Saux1.v = Scons1; 3709 Saux2.v = Scons2; 3710 for( i=0; i< 8; i++ ) 3711 { 3712 if (Saux1.e[i]>255) 3713 UCaux = 255; 3714 else if (Saux1.e[i]<0) 3715 UCaux = 0; 3716 else 3717 UCaux = (unsigned char)Saux1.e[i]; 3718 if (UCaux1.e[i] != UCaux) 3719 err++; 3720 if (Saux2.e[i]>255) 3721 UCaux = 255; 3722 else if (Saux2.e[i]<0) 3723 UCaux = 0; 3724 else 3725 UCaux = (unsigned char)Saux2.e[i]; 3726 if (UCaux1.e[i+8] != UCaux) 3727 err++; 3728 } 3729 if (err) 3730 printf("Function vec_packsu [type char] ===> Error\n"); 3731 else 3732 printf("Function vec_packsu [type char] ===> OK\n"); 3733 3734 err = 0; 3735 UCaux1.v = vec_packsu( UScons1, UScons2 ); 3736 USaux1.v = UScons1; 3737 USaux2.v = UScons2; 3738 for( i=0; i< 8; i++ ) 3739 { 3740 if (USaux1.e[i]>255) 3741 UCaux = 255; 3742 else 3743 UCaux = (unsigned char)USaux1.e[i]; 3744 if (UCaux1.e[i] != UCaux) 3745 err++; 3746 if (USaux2.e[i]>255) 3747 UCaux = 255; 3748 else 3749 UCaux = (unsigned char)USaux2.e[i]; 3750 if (UCaux1.e[i+8] != UCaux) 3751 err++; 3752 } 3753 if (err) 3754 printf("Function vec_packsu [type unsigned char] ===> Error\n"); 3755 else 3756 printf("Function vec_packsu [type unsigned char] ===> OK\n"); 3757 3758 err = 0; 3759 USaux1.v = vec_packsu( Icons1, Icons2 ); 3760 Iaux1.v = Icons1; 3761 Iaux2.v = Icons2; 3762 for( i=0; i< 4; i++ ) 3763 { 3764 if (Iaux1.e[i]>65535) 3765 USaux = 65535; 3766 else if (Iaux1.e[i]<0) 3767 USaux = 0; 3768 else 3769 USaux = (unsigned short)Iaux1.e[i]; 3770 if (USaux1.e[i] != USaux) 3771 err++; 3772 if (Iaux2.e[i]>65535) 3773 USaux = 65535; 3774 else if (Iaux2.e[i]<0) 3775 USaux = 0; 3776 else 3777 USaux = (unsigned short)Iaux2.e[i]; 3778 if (USaux1.e[i+4] != USaux) 3779 err++; 3780 } 3781 if (err) 3782 printf("Function vec_packsu [type short] ===> Error\n"); 3783 else 3784 printf("Function vec_packsu [type short] ===> OK\n"); 3785 3786 err = 0; 3787 USaux1.v = vec_packsu( UIcons1, UIcons2 ); 3788 UIaux1.v = UIcons1; 3789 UIaux2.v = UIcons2; 3790 for( i=0; i< 4; i++ ) 3791 { 3792 if (UIaux1.e[i]>65535) 3793 USaux = 65535; 3794 else 3795 USaux = (unsigned char)UIaux1.e[i]; 3796 if (USaux1.e[i] != USaux) 3797 err++; 3798 if (UIaux2.e[i]>65535) 3799 USaux = 65535; 3800 else 3801 USaux = (unsigned char)UIaux2.e[i]; 3802 if (USaux1.e[i+4] != USaux) 3803 err++; 3804 } 3805 if (err) 3806 printf("Function vec_packsu [type unsigned short] ===> Error\n"); 3807 else 3808 printf("Function vec_packsu [type unsigned short] ===> OK\n"); 3809 3810 /* Function vec_perm */ 3811 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3812 printf("Function vec_perm [Vector Permute] not checked\n"); 3813 3814 #if defined TEST_FLOATS 3815 /* Function vec_re */ 3816 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3817 err = 0; 3818 Faux1.v = vec_re( Fcons1 ); 3819 Faux2.v = Fcons1; 3820 for( i=0; i< 4; i++ ) 3821 { 3822 Faux = 1/Faux2.e[i]; 3823 if (Faux!=0.0) 3824 Faux = (Faux - Faux1.e[i])/Faux; 3825 else 3826 Faux = Faux - Faux1.e[i]; 3827 if (Faux>(1.0/4096.0)) 3828 err++; 3829 } 3830 if (err) 3831 printf("Function vec_re [type float] ===> Error\n"); 3832 else 3833 printf("Function vec_re [type float] ===> OK\n"); 3834 #endif 3835 3836 /* Function vec_rl */ 3837 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3838 err = 0; 3839 Caux1.v = vec_rl( Ccons1, UCcons3 ); 3840 Caux2.v = Ccons1; 3841 UCaux1.v = UCcons3; 3842 for( i=0; i< 16; i++ ) 3843 { 3844 b = UCaux1.e[i]; 3845 UCvec1 = (unsigned char *)(&Caux2.e[i]); 3846 Caux = ((*UCvec1)>>(8-b)) | ((*UCvec1)<<b); 3847 if (Caux1.e[i] != Caux) 3848 err++; 3849 } 3850 if (err) 3851 printf("Function vec_rl [type char] ===> Error\n"); 3852 else 3853 printf("Function vec_rl [type char] ===> OK\n"); 3854 3855 err = 0; 3856 UCaux1.v = vec_rl( UCcons1, UCcons3 ); 3857 UCaux2.v = UCcons1; 3858 UCaux3.v = UCcons3; 3859 for( i=0; i< 16; i++ ) 3860 { 3861 b = UCaux3.e[i]; 3862 UCaux = (UCaux2.e[i]>>(8-b)) | (UCaux2.e[i]<<b); 3863 if (UCaux1.e[i] != UCaux) 3864 err++; 3865 } 3866 if (err) 3867 printf("Function vec_rl [type unsigned char] ===> Error\n"); 3868 else 3869 printf("Function vec_rl [type unsigned char] ===> OK\n"); 3870 3871 err = 0; 3872 Saux1.v = vec_rl( Scons1, UScons3 ); 3873 Saux2.v = Scons1; 3874 USaux1.v = UScons3; 3875 for( i=0; i< 8; i++ ) 3876 { 3877 b = USaux1.e[i]; 3878 USvec1 = (unsigned short *)(&Saux2.e[i]); 3879 Saux = ((*USvec1)>>(16-b)) | ((*USvec1)<<b); 3880 if (Saux1.e[i] != Saux) 3881 err++; 3882 } 3883 if (err) 3884 printf("Function vec_rl [type short] ===> Error\n"); 3885 else 3886 printf("Function vec_rl [type short] ===> OK\n"); 3887 3888 err = 0; 3889 USaux1.v = vec_rl( UScons1, UScons3 ); 3890 USaux2.v = UScons1; 3891 USaux3.v = UScons3; 3892 for( i=0; i< 8; i++ ) 3893 { 3894 b = USaux3.e[i]; 3895 USaux = (USaux2.e[i]>>(16-b)) | (USaux2.e[i]<<b); 3896 if (USaux1.e[i] != USaux) 3897 err++; 3898 } 3899 if (err) 3900 printf("Function vec_rl [type unsigned short] ===> Error\n"); 3901 else 3902 printf("Function vec_rl [type unsigned short] ===> OK\n"); 3903 3904 err = 0; 3905 Iaux1.v = vec_rl( Icons1, UIcons3 ); 3906 Iaux2.v = Icons1; 3907 UIaux1.v = UIcons3; 3908 for( i=0; i< 4; i++ ) 3909 { 3910 b = UIaux1.e[i]; 3911 UIvec1 = (unsigned int *)(&Iaux2.e[i]); 3912 Iaux = ((*UIvec1)>>(32-b)) | ((*UIvec1)<<b); 3913 if (Iaux1.e[i] != Iaux) 3914 err++; 3915 } 3916 if (err) 3917 printf("Function vec_rl [type integer] ===> Error\n"); 3918 else 3919 printf("Function vec_rl [type integer] ===> OK\n"); 3920 3921 err = 0; 3922 UIaux1.v = vec_rl( UIcons1, UIcons3 ); 3923 UIaux2.v = UIcons1; 3924 UIaux3.v = UIcons3; 3925 for( i=0; i< 4; i++ ) 3926 { 3927 b = UIaux3.e[i]; 3928 UIaux = (UIaux2.e[i]>>(32-b)) | (UIaux2.e[i]<<b); 3929 if (UIaux1.e[i] != UIaux) 3930 err++; 3931 } 3932 if (err) 3933 printf("Function vec_rl [type unsigned int] ===> Error\n"); 3934 else 3935 printf("Function vec_rl [type unsigned int] ===> OK\n"); 3936 3937 #if defined TEST_FLOATS 3938 /* Function vec_round */ 3939 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3940 err = 0; 3941 Faux1.v = vec_round( Fcons1 ); 3942 Faux2.v = Fcons1; 3943 for( i=0; i< 4; i++ ) 3944 { 3945 Faux = floor(Faux2.e[i]); 3946 if ((Faux2.e[i]-Faux)>0.5) 3947 Faux = Faux + 1.0; 3948 else if (((Faux2.e[i]-Faux)==0.5)&&(Iaux%2)) 3949 Faux = Faux + 1.0; 3950 if (Faux1.e[i] != Faux) 3951 err++; 3952 } 3953 if (err) 3954 printf("Function vec_round [type float] ===> Error\n"); 3955 else 3956 printf("Function vec_round [type float] ===> OK\n"); 3957 #endif 3958 3959 #if defined TEST_FLOATS 3960 /* Function vec_rsqrte */ 3961 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3962 err = 0; 3963 Faux1.v = vec_rsqrte( Fcons1 ); 3964 Faux2.v = Fcons1; 3965 for( i=0; i< 4; i++ ) 3966 { 3967 Faux = sqrtf(Faux2.e[i]); 3968 if (Faux>0.0) 3969 Faux = (Faux - Faux1.e[i])/Faux; 3970 else if (Faux==0.0) 3971 Faux = Faux - Faux1.e[i]; 3972 if (Faux>(1.0/4096.0)) 3973 err++; 3974 } 3975 if (err) 3976 printf("Function vec_rsqrte [type float] ===> Error\n"); 3977 else 3978 printf("Function vec_rsqrte [type float] ===> OK\n"); 3979 #endif 3980 3981 /* Function vec_sel */ 3982 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 3983 err = 0; 3984 Caux1.v = vec_sel( Ccons1, Ccons2, UCcons1 ); 3985 Caux2.v = Ccons1; 3986 Caux3.v = Ccons2; 3987 UCaux1.v = UCcons1; 3988 for( i=0; i< 16; i++ ) 3989 { 3990 Caux = (Caux2.e[i] & (~UCaux1.e[i])) | (Caux3.e[i] & UCaux1.e[i]); 3991 if (Caux1.e[i] != Caux) 3992 err++; 3993 } 3994 if (err) 3995 printf("Function vec_sel [type char] ===> Error\n"); 3996 else 3997 printf("Function vec_sel [type char] ===> OK\n"); 3998 3999 err = 0; 4000 UCaux1.v = vec_sel( UCcons1, UCcons2, UCcons3 ); 4001 UCaux2.v = UCcons1; 4002 UCaux3.v = UCcons2; 4003 UCaux4.v = UCcons3; 4004 for( i=0; i< 16; i++ ) 4005 { 4006 UCaux = (UCaux2.e[i] & (~UCaux4.e[i])) | (UCaux3.e[i] & UCaux4.e[i]); 4007 if (UCaux1.e[i] != UCaux) 4008 err++; 4009 } 4010 if (err) 4011 printf("Function vec_sel [type unsigned char] ===> Error\n"); 4012 else 4013 printf("Function vec_sel [type unsigned char] ===> OK\n"); 4014 4015 err = 0; 4016 Saux1.v = vec_sel( Scons1, Scons2, UScons1 ); 4017 Saux2.v = Scons1; 4018 Saux3.v = Scons2; 4019 USaux1.v = UScons1; 4020 for( i=0; i< 8; i++ ) 4021 { 4022 Saux = (Saux2.e[i] & (~USaux1.e[i])) | (Saux3.e[i] & USaux1.e[i]); 4023 if (Saux1.e[i] != Saux) 4024 err++; 4025 } 4026 if (err) 4027 printf("Function vec_sel [type short] ===> Error\n"); 4028 else 4029 printf("Function vec_sel [type short] ===> OK\n"); 4030 4031 err = 0; 4032 USaux1.v = vec_sel( UScons1, UScons2, UScons3 ); 4033 USaux2.v = UScons1; 4034 USaux3.v = UScons2; 4035 USaux4.v = UScons3; 4036 for( i=0; i< 8; i++ ) 4037 { 4038 USaux = (USaux2.e[i] & (~USaux4.e[i])) | (USaux3.e[i] & USaux4.e[i]); 4039 if (USaux1.e[i] != USaux) 4040 err++; 4041 } 4042 if (err) 4043 printf("Function vec_sel [type unsigned short] ===> Error\n"); 4044 else 4045 printf("Function vec_sel [type unsigned short] ===> OK\n"); 4046 4047 err = 0; 4048 Iaux1.v = vec_sel( Icons1, Icons2, UIcons1 ); 4049 Iaux2.v = Icons1; 4050 Iaux3.v = Icons2; 4051 UIaux1.v = UIcons1; 4052 for( i=0; i< 4; i++ ) 4053 { 4054 Iaux = (Iaux2.e[i] & (~UIaux1.e[i])) | (Iaux3.e[i] & UIaux1.e[i]); 4055 if (Iaux1.e[i] != Iaux) 4056 err++; 4057 } 4058 if (err) 4059 printf("Function vec_sel [type integer] ===> Error\n"); 4060 else 4061 printf("Function vec_sel [type integer] ===> OK\n"); 4062 4063 err = 0; 4064 UIaux1.v = vec_sel( UIcons1, UIcons2, UIcons3 ); 4065 UIaux2.v = UIcons1; 4066 UIaux3.v = UIcons2; 4067 UIaux4.v = UIcons3; 4068 for( i=0; i< 4; i++ ) 4069 { 4070 UIaux = (UIaux2.e[i] & (~UIaux4.e[i])) | (UIaux3.e[i] & UIaux4.e[i]); 4071 if (UIaux1.e[i] != UIaux) 4072 err++; 4073 } 4074 if (err) 4075 printf("Function vec_sel [type unsigned int] ===> Error\n"); 4076 else 4077 printf("Function vec_sel [type unsigned int] ===> OK\n"); 4078 4079 #if defined TEST_FLOATS 4080 err = 0; 4081 Faux1.v = vec_sel( Fcons1, Fcons2, UIcons1 ); 4082 Faux2.v = Fcons1; 4083 Faux3.v = Fcons2; 4084 UIaux1.v = UIcons1; 4085 for( i=0; i< 4; i++ ) 4086 { 4087 Ivec1 = Faux2.i[i]; 4088 Ivec2 = Faux3.i[i]; 4089 Iaux = (Ivec1 & (~UIaux1.e[i])) | (Ivec2 & UIaux1.e[i]); 4090 Ivec1 = Faux1.i[i]; 4091 if ((Ivec1) != Iaux) 4092 err++; 4093 } 4094 if (err) 4095 printf("Function vec_sel [type float] ===> Error\n"); 4096 else 4097 printf("Function vec_sel [type float] ===> OK\n"); 4098 #endif 4099 4100 /* Function vec_sl */ 4101 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4102 err = 0; 4103 Caux1.v = vec_sl( Ccons1, UCcons3 ); 4104 Caux2.v = Ccons1; 4105 UCaux1.v = UCcons3; 4106 for( i=0; i< 16; i++ ) 4107 { 4108 b = UCaux1.e[i]%(128/16); 4109 Caux = Caux2.e[i] << b; 4110 if (Caux1.e[i] != Caux) 4111 err++; 4112 } 4113 if (err) 4114 printf("Function vec_sl [type char] ===> Error\n"); 4115 else 4116 printf("Function vec_sl [type char] ===> OK\n"); 4117 4118 err = 0; 4119 UCaux1.v = vec_sl( UCcons1, UCcons3 ); 4120 UCaux2.v = UCcons1; 4121 UCaux3.v = UCcons3; 4122 for( i=0; i< 16; i++ ) 4123 { 4124 b = UCaux3.e[i]%(128/16); 4125 UCaux = UCaux2.e[i] << b; 4126 if (UCaux1.e[i] != UCaux) 4127 err++; 4128 } 4129 if (err) 4130 printf("Function vec_sl [type unsigned char] ===> Error\n"); 4131 else 4132 printf("Function vec_sl [type unsigned char] ===> OK\n"); 4133 4134 err = 0; 4135 Saux1.v = vec_sl( Scons1, UScons3 ); 4136 Saux2.v = Scons1; 4137 USaux1.v = UScons3; 4138 for( i=0; i< 8; i++ ) 4139 { 4140 b = USaux1.e[i]%(128/8); 4141 Saux = Saux2.e[i] << b; 4142 if (Saux1.e[i] != Saux) 4143 err++; 4144 } 4145 if (err) 4146 printf("Function vec_sl [type short] ===> Error\n"); 4147 else 4148 printf("Function vec_sl [type short] ===> OK\n"); 4149 4150 err = 0; 4151 USaux1.v = vec_sl( UScons1, UScons3 ); 4152 USaux2.v = UScons1; 4153 USaux3.v = UScons3; 4154 for( i=0; i< 8; i++ ) 4155 { 4156 b = USaux3.e[i]%(128/8); 4157 USaux = USaux2.e[i] << b; 4158 if (USaux1.e[i] != USaux) 4159 err++; 4160 } 4161 if (err) 4162 printf("Function vec_sl [type unsigned short] ===> Error\n"); 4163 else 4164 printf("Function vec_sl [type unsigned short] ===> OK\n"); 4165 4166 err = 0; 4167 Iaux1.v = vec_sl( Icons1, UIcons3 ); 4168 Iaux2.v = Icons1; 4169 UIaux1.v = UIcons3; 4170 for( i=0; i< 4; i++ ) 4171 { 4172 b = UIaux1.e[i]%(128/4); 4173 Iaux = Iaux2.e[i] << b; 4174 if (Iaux1.e[i] != Iaux) 4175 err++; 4176 } 4177 if (err) 4178 printf("Function vec_sl [type int] ===> Error\n"); 4179 else 4180 printf("Function vec_sl [type int] ===> OK\n"); 4181 4182 err = 0; 4183 UIaux1.v = vec_sl( UIcons1, UIcons3 ); 4184 UIaux2.v = UIcons1; 4185 UIaux3.v = UIcons3; 4186 for( i=0; i< 4; i++ ) 4187 { 4188 b = UIaux3.e[i]%(128/4); 4189 UIaux = UIaux2.e[i] << b; 4190 if (UIaux1.e[i] != UIaux) 4191 err++; 4192 } 4193 if (err) 4194 printf("Function vec_sl [type unsigned integer] ===> Error\n"); 4195 else 4196 printf("Function vec_sl [type unsigned integer] ===> OK\n"); 4197 4198 /* Function vec_sld */ 4199 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4200 err = 0; 4201 b = 3; 4202 Caux1.v = vec_sld( Ccons1, Ccons2, 3 ); 4203 Caux2.v = Ccons1; 4204 Caux3.v = Ccons2; 4205 for( i=0; i< 16; i++ ) 4206 { 4207 if ((i+b)<16) 4208 { 4209 if (Caux1.e[i] != Caux2.e[i+b]) 4210 err++; 4211 } 4212 else 4213 { 4214 if (Caux1.e[i] != Caux3.e[i+b-16]) 4215 err++; 4216 } 4217 } 4218 if (err) 4219 printf("Function vec_sld [type char] ===> Error\n"); 4220 else 4221 printf("Function vec_sld [type char] ===> OK\n"); 4222 4223 err = 0; 4224 b = 3; 4225 UCaux1.v = vec_sld( UCcons1, UCcons2, 3 ); 4226 UCaux2.v = UCcons1; 4227 UCaux3.v = UCcons2; 4228 for( i=0; i< 16; i++ ) 4229 { 4230 if ((i+b)<16) 4231 { 4232 if (UCaux1.e[i] != UCaux2.e[i+b]) 4233 err++; 4234 } 4235 else 4236 { 4237 if (UCaux1.e[i] != UCaux3.e[i+b-16]) 4238 err++; 4239 } 4240 } 4241 if (err) 4242 printf("Function vec_sld [type unsigned char] ===> Error\n"); 4243 else 4244 printf("Function vec_sld [type unsigned char] ===> OK\n"); 4245 4246 err = 0; 4247 b = 3; 4248 Saux1.v = vec_sld( Scons1, Scons2, 3 ); 4249 Saux2.v = Scons1; 4250 Saux3.v = Scons2; 4251 for( i=0; i< 16; i++ ) 4252 { 4253 SHOunion1.ss = Saux1.e[i/2]; 4254 if ((i+b)<16) 4255 SHOunion2.ss = Saux2.e[(i+b)/2]; 4256 else 4257 SHOunion2.ss = Saux3.e[(i+b-16)/2]; 4258 if (SHOunion1.sc[i%2] != SHOunion2.sc[(i+b)%2]) 4259 err++; 4260 } 4261 if (err) 4262 printf("Function vec_sld [type short] ===> Error\n"); 4263 else 4264 printf("Function vec_sld [type short] ===> OK\n"); 4265 4266 err = 0; 4267 b = 3; 4268 USaux1.v = vec_sld( UScons1, UScons2, 3 ); 4269 USaux2.v = UScons1; 4270 USaux3.v = UScons2; 4271 for( i=0; i< 16; i++ ) 4272 { 4273 SHOunion1.us = USaux1.e[i/2]; 4274 if ((i+b)<16) 4275 SHOunion2.us = USaux2.e[(i+b)/2]; 4276 else 4277 SHOunion2.us = USaux3.e[(i+b-16)/2]; 4278 if (SHOunion1.uc[i%2] != SHOunion2.uc[(i+b)%2]) 4279 err++; 4280 } 4281 if (err) 4282 printf("Function vec_sld [type unsigned short] ===> Error\n"); 4283 else 4284 printf("Function vec_sld [type unsigned short] ===> OK\n"); 4285 4286 err = 0; 4287 b = 3; 4288 Iaux1.v = vec_sld( Icons1, Icons2, 3 ); 4289 Iaux2.v = Icons1; 4290 Iaux3.v = Icons2; 4291 for( i=0; i< 16; i++ ) 4292 { 4293 INTunion1.si = Iaux1.e[i/4]; 4294 if ((i+b)<16) 4295 INTunion2.si = Iaux2.e[(i+b)/4]; 4296 else 4297 INTunion2.si = Iaux3.e[(i+b-16)/4]; 4298 if (INTunion1.sc[i%4] != INTunion2.sc[(i+b)%4]) 4299 err++; 4300 } 4301 if (err) 4302 printf("Function vec_sld [type integer] ===> Error\n"); 4303 else 4304 printf("Function vec_sld [type integer] ===> OK\n"); 4305 4306 err = 0; 4307 b = 3; 4308 UIaux1.v = vec_sld( UIcons1, UIcons2, 3 ); 4309 UIaux2.v = UIcons1; 4310 UIaux3.v = UIcons2; 4311 for( i=0; i< 16; i++ ) 4312 { 4313 INTunion1.ui = UIaux1.e[i/4]; 4314 if ((i+b)<16) 4315 INTunion2.ui = UIaux2.e[(i+b)/4]; 4316 else 4317 INTunion2.ui = UIaux3.e[(i+b-16)/4]; 4318 if (INTunion1.uc[i%4] != INTunion2.uc[(i+b)%4]) 4319 err++; 4320 } 4321 if (err) 4322 printf("Function vec_sld [type unsigned int] ===> Error\n"); 4323 else 4324 printf("Function vec_sld [type unsigned int] ===> OK\n"); 4325 4326 #if defined TEST_FLOATS 4327 err = 0; 4328 b = 3; 4329 Faux1.v = vec_sld( Fcons1, Fcons2, 3 ); 4330 Faux2.v = Fcons1; 4331 Faux3.v = Fcons2; 4332 for( i=0; i< 16; i++ ) 4333 { 4334 INTunion1.f = Faux1.e[i/4]; 4335 if ((i+b)<16) 4336 INTunion2.f = Faux2.e[(i+b)/4]; 4337 else 4338 INTunion2.f = Faux3.e[(i+b-16)/4]; 4339 if (INTunion1.sc[i%4] != INTunion2.sc[(i+b)%4]) 4340 err++; 4341 } 4342 if (err) 4343 printf("Function vec_sld [type float] ===> Error\n"); 4344 else 4345 printf("Function vec_sld [type float] ===> OK\n"); 4346 #endif 4347 4348 /* Function vec_sll */ 4349 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4350 err = 0; 4351 Caux1.v = vec_sll( Ccons1, UCcons2 ); 4352 Caux2.v = Ccons1; 4353 UCaux1.v = UCcons2; 4354 b = UCaux1.e[15] & 0x7; 4355 for( i=0; i< 15; i++ ) 4356 if ((UCaux1.e[i] & 0x7)!=b) 4357 err++; 4358 if (err) 4359 { 4360 printf("The three low-order bits of all byte elements in b must be the same\n"); 4361 printf("otherwise the value into d is undefined\n"); 4362 } 4363 else 4364 { 4365 for( i=0; i< 16; i++ ) 4366 { 4367 UCvec1 = (unsigned char *)(&Caux2.e[i]); 4368 Caux = UCvec1[0]<<b; 4369 if (i != 15) 4370 Caux = Caux | (UCvec1[1]>>(8-b)); 4371 if (Caux != Caux1.e[i]) 4372 err++; 4373 } 4374 if (err) 4375 printf("Function vec_sll [type char] ===> Error\n"); 4376 else 4377 printf("Function vec_sll [type char] ===> OK\n"); 4378 } 4379 4380 UCaux1.v = vec_sll( UCcons1, UCcons2 ); 4381 UCaux2.v = UCcons1; 4382 UCaux3.v = UCcons2; 4383 b = UCaux3.e[15] & 0x7; 4384 for( i=0; i< 15; i++ ) 4385 if ((UCaux3.e[i] & 0x7)!=b) 4386 err++; 4387 if (err) 4388 { 4389 printf("The three low-order bits of all byte elements in b must be the same\n"); 4390 printf("otherwise the value into d is undefined\n"); 4391 } 4392 else 4393 { 4394 for( i=0; i< 16; i++ ) 4395 { 4396 UCvec1 = (unsigned char *)(&UCaux2.e[i]); 4397 UCaux = UCvec1[0]<<b; 4398 if (i != 15) 4399 UCaux = UCaux | (UCvec1[1]>>(8-b)); 4400 if (UCaux != UCaux1.e[i]) 4401 err++; 4402 } 4403 if (err) 4404 printf("Function vec_sll [type unsigned char] ===> Error\n"); 4405 else 4406 printf("Function vec_sll [type unsigned char] ===> OK\n"); 4407 } 4408 4409 err = 0; 4410 Saux1.v = vec_sll( Scons1, UCcons2 ); 4411 Saux2.v = Scons1; 4412 UCaux1.v = UCcons2; 4413 b = UCaux1.e[15] & 0x7; 4414 for( i=0; i< 15; i++ ) 4415 if ((UCaux1.e[i] & 0x7)!=b) 4416 err++; 4417 if (err) 4418 { 4419 printf("The three low-order bits of all byte elements in b must be the same\n"); 4420 printf("otherwise the value into d is undefined\n"); 4421 } 4422 else 4423 { 4424 for( i=0; i< 8; i++ ) 4425 { 4426 USvec1 = (unsigned short *)(&Saux2.e[i]); 4427 Saux = USvec1[0]<<b; 4428 if (i != 7) 4429 Saux = Saux | (USvec1[1]>>(16-b)); 4430 if (Saux != Saux1.e[i]) 4431 err++; 4432 } 4433 if (err) 4434 printf("Function vec_sll [type short] ===> Error\n"); 4435 else 4436 printf("Function vec_sll [type short] ===> OK\n"); 4437 } 4438 4439 USaux1.v = vec_sll( UScons1, UCcons2 ); 4440 USaux2.v = UScons1; 4441 UCaux1.v = UCcons2; 4442 b = UCaux1.e[15] & 0x7; 4443 for( i=0; i< 15; i++ ) 4444 if ((UCaux1.e[i] & 0x7)!=b) 4445 err++; 4446 if (err) 4447 { 4448 printf("The three low-order bits of all byte elements in b must be the same\n"); 4449 printf("otherwise the value into d is undefined\n"); 4450 } 4451 else 4452 { 4453 for( i=0; i< 8; i++ ) 4454 { 4455 USvec1 = (unsigned short *)(&USaux2.e[i]); 4456 USaux = USvec1[0]<<b; 4457 if (i != 7) 4458 USaux = USaux | (USvec1[1]>>(16-b)); 4459 if (USaux != USaux1.e[i]) 4460 err++; 4461 } 4462 if (err) 4463 printf("Function vec_sll [type unsigned char] ===> Error\n"); 4464 else 4465 printf("Function vec_sll [type unsigned char] ===> OK\n"); 4466 } 4467 4468 err = 0; 4469 Iaux1.v = vec_sll( Icons1, UCcons2 ); 4470 Iaux2.v = Icons1; 4471 UCaux1.v = UCcons2; 4472 b = UCaux1.e[15] & 0x7; 4473 for( i=0; i< 15; i++ ) 4474 if ((UCaux1.e[i] & 0x7)!=b) 4475 err++; 4476 if (err) 4477 { 4478 printf("The three low-order bits of all byte elements in b must be the same\n"); 4479 printf("otherwise the value into d is undefined\n"); 4480 } 4481 else 4482 { 4483 for( i=0; i< 4; i++ ) 4484 { 4485 UIvec1 = (unsigned int *)(&Iaux2.e[i]); 4486 Iaux = UIvec1[0]<<b; 4487 if (i != 3) 4488 Iaux = Iaux | (UIvec1[1]>>(32-b)); 4489 if (Iaux != Iaux1.e[i]) 4490 err++; 4491 } 4492 if (err) 4493 printf("Function vec_sll [type integer] ===> Error\n"); 4494 else 4495 printf("Function vec_sll [type integer] ===> OK\n"); 4496 } 4497 4498 UIaux1.v = vec_sll( UIcons1, UCcons2 ); 4499 UIaux2.v = UIcons1; 4500 UCaux1.v = UCcons2; 4501 b = UCaux1.e[15] & 0x7; 4502 for( i=0; i< 15; i++ ) 4503 if ((UCaux1.e[i] & 0x7)!=b) 4504 err++; 4505 if (err) 4506 { 4507 printf("The three low-order bits of all byte elements in b must be the same\n"); 4508 printf("otherwise the value into d is undefined\n"); 4509 } 4510 else 4511 { 4512 for( i=0; i< 4; i++ ) 4513 { 4514 UIvec1 = (unsigned int *)(&UIaux2.e[i]); 4515 UIaux = UIvec1[0]<<b; 4516 if (i != 3) 4517 UIaux = UIaux | (UIvec1[1]>>(32-b)); 4518 if (UIaux != UIaux1.e[i]) 4519 err++; 4520 } 4521 if (err) 4522 printf("Function vec_sll [type unsigned int] ===> Error\n"); 4523 else 4524 printf("Function vec_sll [type unsigned int] ===> OK\n"); 4525 } 4526 4527 /* Function vec_slo */ 4528 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4529 err = 0; 4530 Caux1.v = vec_slo( Ccons3, Ccons1 ); 4531 Caux2.v = Ccons3; 4532 Caux3.v = Ccons1; 4533 b = (Caux3.e[15] & 0x78) >> 3; 4534 for( i=0; i< 16; i++ ) 4535 { 4536 if ((i+b)<16) 4537 { 4538 if (Caux1.e[i] != Caux2.e[i+b]) 4539 err++; 4540 } 4541 else 4542 { 4543 if (Caux1.e[i] != 0) 4544 err++; 4545 } 4546 } 4547 if (err) 4548 printf("Function vec_slo [type char] ===> Error\n"); 4549 else 4550 printf("Function vec_slo [type char] ===> OK\n"); 4551 4552 err = 0; 4553 UCaux1.v = vec_slo( UCcons3, UCcons1 ); 4554 UCaux2.v = UCcons3; 4555 UCaux3.v = UCcons1; 4556 b = (UCaux3.e[15] & 0x78) >> 3; 4557 for( i=0; i< 16; i++ ) 4558 { 4559 if ((i+b)<16) 4560 { 4561 if (UCaux1.e[i] != UCaux2.e[i+b]) 4562 err++; 4563 } 4564 else 4565 { 4566 if (UCaux1.e[i] != 0) 4567 err++; 4568 } 4569 } 4570 if (err) 4571 printf("Function vec_slo [type unsigned char] ===> Error\n"); 4572 else 4573 printf("Function vec_slo [type unsigned char] ===> OK\n"); 4574 4575 err = 0; 4576 Saux1.v = vec_slo( Scons3, UCcons1 ); 4577 Saux2.v = Scons3; 4578 UCaux3.v = UCcons1; 4579 b = (UCaux3.e[15] & 0x78) >> 3; 4580 for( i=0; i< 16; i++ ) 4581 { 4582 SHOunion1.ss = Saux1.e[i/2]; 4583 if ((i+b)<16) 4584 SHOunion2.ss = Saux2.e[(i+b)/2]; 4585 else 4586 SHOunion2.ss = 0; 4587 if (SHOunion1.sc[i%2] != SHOunion2.sc[(i+b)%2]) 4588 err++; 4589 } 4590 if (err) 4591 printf("Function vec_slo [type short] ===> Error\n"); 4592 else 4593 printf("Function vec_slo [type short] ===> OK\n"); 4594 4595 err = 0; 4596 USaux1.v = vec_slo( UScons3, UCcons1 ); 4597 USaux2.v = UScons3; 4598 UCaux3.v = UCcons1; 4599 b = (UCaux3.e[15] & 0x78) >> 3; 4600 for( i=0; i< 16; i++ ) 4601 { 4602 SHOunion1.us = USaux1.e[i/2]; 4603 if ((i+b)<16) 4604 SHOunion2.us = USaux2.e[(i+b)/2]; 4605 else 4606 SHOunion2.us = 0; 4607 if (SHOunion1.uc[i%2] != SHOunion2.uc[(i+b)%2]) 4608 err++; 4609 } 4610 if (err) 4611 printf("Function vec_slo [type unsigned short] ===> Error\n"); 4612 else 4613 printf("Function vec_slo [type unsigned short] ===> OK\n"); 4614 4615 err = 0; 4616 Iaux1.v = vec_slo( Icons3, UCcons1 ); 4617 Iaux2.v = Icons3; 4618 UCaux3.v = UCcons1; 4619 b = (UCaux3.e[15] & 0x78) >> 3; 4620 for( i=0; i< 16; i++ ) 4621 { 4622 INTunion1.si = Iaux1.e[i/4]; 4623 if ((i+b)<16) 4624 INTunion2.si = Iaux2.e[(i+b)/4]; 4625 else 4626 INTunion2.si = 0; 4627 if (INTunion1.sc[i%4] != INTunion2.sc[(i+b)%4]) 4628 err++; 4629 } 4630 if (err) 4631 printf("Function vec_slo [type integer] ===> Error\n"); 4632 else 4633 printf("Function vec_slo [type integer] ===> OK\n"); 4634 4635 err = 0; 4636 UIaux1.v = vec_slo( UIcons3, UCcons1 ); 4637 UIaux2.v = UIcons3; 4638 UCaux3.v = UCcons1; 4639 b = (UCaux3.e[15] & 0x78) >> 3; 4640 for( i=0; i< 16; i++ ) 4641 { 4642 INTunion1.ui = UIaux1.e[i/4]; 4643 if ((i+b)<16) 4644 INTunion2.ui = UIaux2.e[(i+b)/4]; 4645 else 4646 INTunion2.ui = 0; 4647 if (INTunion1.uc[i%4] != INTunion2.uc[(i+b)%4]) 4648 err++; 4649 } 4650 if (err) 4651 printf("Function vec_slo [type unsigned int] ===> Error\n"); 4652 else 4653 printf("Function vec_slo [type unsigned int] ===> OK\n"); 4654 4655 #if defined TEST_FLOATS 4656 err = 0; 4657 Faux1.v = vec_slo( Fcons3, UCcons1 ); 4658 Faux2.v = Fcons3; 4659 UCaux3.v = UCcons1; 4660 b = (UCaux3.e[15] & 0x78) >> 3; 4661 for( i=0; i< 16; i++ ) 4662 { 4663 INTunion1.f = Faux1.e[i/4]; 4664 if ((i+b)<16) 4665 INTunion2.f = Faux2.e[(i+b)/4]; 4666 else 4667 INTunion2.si = 0; 4668 if (INTunion1.sc[i%4] != INTunion2.sc[(i+b)%4]) 4669 err++; 4670 } 4671 if (err) 4672 printf("Function vec_slo [type float] ===> Error\n"); 4673 else 4674 printf("Function vec_slo [type float] ===> OK\n"); 4675 #endif 4676 4677 /* Function vec_splat */ 4678 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4679 err = 0; 4680 b = 3; 4681 Caux1.v = vec_splat( Ccons1, 3 ); 4682 Caux2.v = Ccons1; 4683 for( i=0; i< 16; i++ ) 4684 if (Caux1.e[i] != Caux2.e[b]) 4685 err++; 4686 if (err) 4687 printf("Function vec_splat [type char] ===> Error\n"); 4688 else 4689 printf("Function vec_splat [type char] ===> OK\n"); 4690 4691 err = 0; 4692 b = 3; 4693 UCaux1.v = vec_splat( UCcons1, 3 ); 4694 UCaux2.v = UCcons1; 4695 for( i=0; i< 16; i++ ) 4696 if (UCaux1.e[i] != UCaux2.e[b]) 4697 err++; 4698 if (err) 4699 printf("Function vec_splat [type unsigned char] ===> Error\n"); 4700 else 4701 printf("Function vec_splat [type unsigned char] ===> OK\n"); 4702 4703 err = 0; 4704 b = 3; 4705 Saux1.v = vec_splat( Scons1, 3 ); 4706 Saux2.v = Scons1; 4707 for( i=0; i< 8; i++ ) 4708 if (Saux1.e[i] != Saux2.e[b]) 4709 err++; 4710 if (err) 4711 printf("Function vec_splat [type short] ===> Error\n"); 4712 else 4713 printf("Function vec_splat [type short] ===> OK\n"); 4714 4715 err = 0; 4716 b = 3; 4717 USaux1.v = vec_splat( UScons1, 3 ); 4718 USaux2.v = UScons1; 4719 for( i=0; i< 8; i++ ) 4720 if (USaux1.e[i] != USaux2.e[b]) 4721 err++; 4722 if (err) 4723 printf("Function vec_splat [type unsigned short] ===> Error\n"); 4724 else 4725 printf("Function vec_splat [type unsigned short] ===> OK\n"); 4726 4727 err = 0; 4728 b = 3; 4729 Iaux1.v = vec_splat( Icons1, 3 ); 4730 Iaux2.v = Icons1; 4731 for( i=0; i< 4; i++ ) 4732 if (Iaux1.e[i] != Iaux2.e[b]) 4733 err++; 4734 if (err) 4735 printf("Function vec_splat [type integer] ===> Error\n"); 4736 else 4737 printf("Function vec_splat [type integer] ===> OK\n"); 4738 4739 err = 0; 4740 b = 3; 4741 UIaux1.v = vec_splat( UIcons1, 3 ); 4742 UIaux2.v = UIcons1; 4743 for( i=0; i< 4; i++ ) 4744 if (UIaux1.e[i] != UIaux2.e[b]) 4745 err++; 4746 if (err) 4747 printf("Function vec_splat [type unsigned int] ===> Error\n"); 4748 else 4749 printf("Function vec_splat [type unsigned int] ===> OK\n"); 4750 4751 #if defined TEST_FLOATS 4752 err = 0; 4753 b = 3; 4754 Faux1.v = vec_splat( Fcons1, 3 ); 4755 Faux2.v = Fcons1; 4756 for( i=0; i< 4; i++ ) 4757 if (Faux1.e[i] != Faux2.e[b]) 4758 err++; 4759 if (err) 4760 printf("Function vec_splat [type float] ===> Error\n"); 4761 else 4762 printf("Function vec_splat [type float] ===> OK\n"); 4763 #endif 4764 4765 /* Function vec_splat_s8 */ 4766 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4767 err = 0; 4768 Caux = 15; 4769 Caux1.v = vec_splat_s8( 15 ); 4770 for( i=0; i< 16; i++ ) 4771 if (Caux1.e[i] != Caux) 4772 err++; 4773 if (err) 4774 printf("Function vec_splat_s8 [type char] ===> Error\n"); 4775 else 4776 printf("Function vec_splat_s8 [type char] ===> OK\n"); 4777 4778 /* Function vec_splat_s16 */ 4779 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4780 err = 0; 4781 Saux = 15; 4782 Saux1.v = vec_splat_s16( 15 ); 4783 for( i=0; i< 8; i++ ) 4784 if (Saux1.e[i] != Saux) 4785 err++; 4786 if (err) 4787 printf("Function vec_splat_s16 [type short] ===> Error\n"); 4788 else 4789 printf("Function vec_splat_s16 [type short] ===> OK\n"); 4790 4791 /* Function vec_splat_s32 */ 4792 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4793 err = 0; 4794 Iaux = 15; 4795 Iaux1.v = vec_splat_s32( 15 ); 4796 for( i=0; i< 4; i++ ) 4797 if (Iaux1.e[i] != Iaux) 4798 err++; 4799 if (err) 4800 printf("Function vec_splat_s32 [type integer] ===> Error\n"); 4801 else 4802 printf("Function vec_splat_s32 [type integer] ===> OK\n"); 4803 4804 /* Function vec_splat_u8 */ 4805 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4806 err = 0; 4807 UCaux = 15; 4808 UCaux1.v = vec_splat_u8( 15 ); 4809 for( i=0; i< 16; i++ ) 4810 if (UCaux1.e[i] != UCaux) 4811 err++; 4812 if (err) 4813 printf("Function vec_splat_u8 [type unsig. char] ===> Error\n"); 4814 else 4815 printf("Function vec_splat_u8 [type unsig. char] ===> OK\n"); 4816 4817 /* Function vec_splat_u16 */ 4818 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4819 err = 0; 4820 USaux = 15; 4821 USaux1.v = vec_splat_u16( 15 ); 4822 for( i=0; i< 8; i++ ) 4823 if (USaux1.e[i] != Saux) 4824 err++; 4825 if (err) 4826 printf("Function vec_splat_u16 [type unsg. short] ===> Error\n"); 4827 else 4828 printf("Function vec_splat_u16 [type unsg. short] ===> OK\n"); 4829 4830 /* Function vec_splat_u32 */ 4831 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4832 err = 0; 4833 UIaux = 15; 4834 UIaux1.v = vec_splat_u32( 15 ); 4835 for( i=0; i< 4; i++ ) 4836 if (UIaux1.e[i] != UIaux) 4837 err++; 4838 if (err) 4839 printf("Function vec_splat_u32 [type unsig. int] ===> Error\n"); 4840 else 4841 printf("Function vec_splat_u32 [type unsig. int] ===> OK\n"); 4842 4843 /* Function vec_sr */ 4844 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4845 err = 0; 4846 Caux1.v = vec_sr( Ccons3, UCcons3 ); 4847 Caux2.v = Ccons3; 4848 UCaux3.v = UCcons3; 4849 for( i=0; i< 16; i++ ) 4850 { 4851 SHOunion1.sc[0] = Caux2.e[i]; 4852 SHOunion1.uc[0] = SHOunion1.uc[0] >> (UCaux3.e[i]%8); 4853 if (Caux1.e[i] != SHOunion1.sc[0]) 4854 err++; 4855 } 4856 if (err) 4857 printf("Function vec_sr [type char] ===> Error\n"); 4858 else 4859 printf("Function vec_sr [type char] ===> OK\n"); 4860 4861 err = 0; 4862 UCaux1.v = vec_sr( UCcons1, UCcons3 ); 4863 UCaux2.v = UCcons1; 4864 UCaux3.v = UCcons3; 4865 for( i=0; i< 16; i++ ) 4866 { 4867 UCaux = UCaux2.e[i] >> (UCaux3.e[i]%8); 4868 if (UCaux1.e[i] != UCaux) 4869 err++; 4870 } 4871 if (err) 4872 printf("Function vec_sr [type unsigned char] ===> Error\n"); 4873 else 4874 printf("Function vec_sr [type unsigned char] ===> OK\n"); 4875 4876 err = 0; 4877 Saux1.v = vec_sr( Scons3, UScons3 ); 4878 Saux2.v = Scons3; 4879 USaux3.v = UScons3; 4880 for( i=0; i< 8; i++ ) 4881 { 4882 SHOunion1.ss = Saux2.e[i]; 4883 SHOunion1.us = SHOunion1.us >> (USaux3.e[i]%16); 4884 if (Saux1.e[i] != SHOunion1.ss) 4885 err++; 4886 } 4887 if (err) 4888 printf("Function vec_sr [type short] ===> Error\n"); 4889 else 4890 printf("Function vec_sr [type short] ===> OK\n"); 4891 4892 err = 0; 4893 USaux1.v = vec_sr( UScons1, UScons3 ); 4894 USaux2.v = UScons1; 4895 USaux3.v = UScons3; 4896 for( i=0; i< 8; i++ ) 4897 { 4898 USaux = USaux2.e[i] >> (USaux3.e[i]%16); 4899 if (USaux1.e[i] != USaux) 4900 err++; 4901 } 4902 if (err) 4903 printf("Function vec_sr [type unsigned short] ===> Error\n"); 4904 else 4905 printf("Function vec_sr [type unsigned short] ===> OK\n"); 4906 4907 err = 0; 4908 Iaux1.v = vec_sr( Icons3, UIcons3 ); 4909 Iaux2.v = Icons3; 4910 UIaux3.v = UIcons3; 4911 for( i=0; i< 4; i++ ) 4912 { 4913 INTunion1.si = Iaux2.e[i]; 4914 INTunion1.ui = INTunion1.ui >> (UIaux3.e[i]%32); 4915 if (Iaux1.e[i] != INTunion1.si) 4916 err++; 4917 } 4918 if (err) 4919 printf("Function vec_sr [type integer] ===> Error\n"); 4920 else 4921 printf("Function vec_sr [type integer] ===> OK\n"); 4922 4923 err = 0; 4924 UIaux1.v = vec_sr( UIcons1, UIcons3 ); 4925 UIaux2.v = UIcons1; 4926 UIaux3.v = UIcons3; 4927 for( i=0; i< 4; i++ ) 4928 { 4929 UIaux = UIaux2.e[i] >> (UIaux3.e[i]%32); 4930 if (UIaux1.e[i] != UIaux) 4931 err++; 4932 } 4933 if (err) 4934 printf("Function vec_sr [type unsigned int] ===> Error\n"); 4935 else 4936 printf("Function vec_sr [type unsigned int] ===> OK\n"); 4937 4938 /* Function vec_sra */ 4939 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 4940 err = 0; 4941 Caux1.v = vec_sra( Ccons3, UCcons3 ); 4942 Caux2.v = Ccons3; 4943 UCaux3.v = UCcons3; 4944 for( i=0; i< 16; i++ ) 4945 { 4946 Caux = Caux2.e[i] >> (UCaux3.e[i]%8); 4947 if (Caux1.e[i] != Caux) 4948 err++; 4949 } 4950 if (err) 4951 printf("Function vec_sra [type char] ===> Error\n"); 4952 else 4953 printf("Function vec_sra [type char] ===> OK\n"); 4954 4955 err = 0; 4956 UCaux1.v = vec_sra( UCcons1, UCcons3 ); 4957 UCaux2.v = UCcons1; 4958 UCaux3.v = UCcons3; 4959 for( i=0; i< 16; i++ ) 4960 { 4961 INTunion1.uc[0] = UCaux2.e[i]; 4962 INTunion1.sc[0] = INTunion1.sc[0] >> (UCaux3.e[i]%8); 4963 if (UCaux1.e[i] != INTunion1.uc[0]) 4964 err++; 4965 } 4966 if (err) 4967 printf("Function vec_sra [type unsigned char] ===> Error\n"); 4968 else 4969 printf("Function vec_sra [type unsigned char] ===> OK\n"); 4970 4971 err = 0; 4972 Saux1.v = vec_sra( Scons3, UScons3 ); 4973 Saux2.v = Scons3; 4974 USaux3.v = UScons3; 4975 for( i=0; i< 8; i++ ) 4976 { 4977 Saux = Saux2.e[i] >> (USaux3.e[i]%16); 4978 if (Saux1.e[i] != Saux) 4979 err++; 4980 } 4981 if (err) 4982 printf("Function vec_sra [type short] ===> Error\n"); 4983 else 4984 printf("Function vec_sra [type short] ===> OK\n"); 4985 4986 err = 0; 4987 USaux1.v = vec_sra( UScons1, UScons3 ); 4988 USaux2.v = UScons1; 4989 USaux3.v = UScons3; 4990 for( i=0; i< 8; i++ ) 4991 { 4992 INTunion1.us[0] = USaux2.e[i]; 4993 INTunion1.ss[0] = INTunion1.ss[0] >> (USaux3.e[i]%16); 4994 if (USaux1.e[i] != INTunion1.us[0]) 4995 err++; 4996 } 4997 if (err) 4998 printf("Function vec_sra [type unsigned short] ===> Error\n"); 4999 else 5000 printf("Function vec_sra [type unsigned short] ===> OK\n"); 5001 5002 err = 0; 5003 Iaux1.v = vec_sra( Icons3, UIcons3 ); 5004 Iaux2.v = Icons3; 5005 UIaux3.v = UIcons3; 5006 for( i=0; i< 4; i++ ) 5007 { 5008 Iaux = Iaux2.e[i] >> (UIaux3.e[i]%32); 5009 if (Iaux1.e[i] != Iaux) 5010 err++; 5011 } 5012 if (err) 5013 printf("Function vec_sra [type integer] ===> Error\n"); 5014 else 5015 printf("Function vec_sra [type integer] ===> OK\n"); 5016 5017 err = 0; 5018 UIaux1.v = vec_sra( UIcons1, UIcons3 ); 5019 UIaux2.v = UIcons1; 5020 UIaux3.v = UIcons3; 5021 for( i=0; i< 4; i++ ) 5022 { 5023 INTunion1.ui = UIaux2.e[i]; 5024 INTunion1.si = INTunion1.si >> (UIaux3.e[i]%32); 5025 if (UIaux1.e[i] != INTunion1.ui) 5026 err++; 5027 } 5028 if (err) 5029 printf("Function vec_sra [type unsigned int] ===> Error\n"); 5030 else 5031 printf("Function vec_sra [type unsigned int] ===> OK\n"); 5032 5033 /* Function vec_srl */ 5034 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 5035 err = 0; 5036 Caux1.v = vec_srl( Ccons1, UCcons2 ); 5037 Caux2.v = Ccons1; 5038 UCaux3.v = UCcons2; 5039 b = UCaux3.e[15] & 0x7; 5040 for( i=0; i< 15; i++ ) 5041 if ((UCaux3.e[i] & 0x7)!=b) 5042 err++; 5043 if (err) 5044 { 5045 printf("The three low-order bits of all byte elements in b must be the same\n"); 5046 printf("otherwise the value into d is undefined\n"); 5047 } 5048 else 5049 { 5050 Caux = 0; 5051 for( i=0; i< 16; i++ ) 5052 { 5053 INTunion1.sc[0] = Caux2.e[i]; 5054 Caux = Caux | (INTunion1.uc[0]>>b); 5055 if (Caux != Caux1.e[i]) 5056 err++; 5057 Caux = INTunion1.uc[0]<<(8-b); 5058 } 5059 if (err) 5060 printf("Function vec_srl [type char] ===> Error\n"); 5061 else 5062 printf("Function vec_srl [type char] ===> OK\n"); 5063 } 5064 5065 err = 0; 5066 UCaux1.v = vec_srl( UCcons1, UCcons2 ); 5067 UCaux2.v = UCcons1; 5068 UCaux3.v = UCcons2; 5069 b = UCaux3.e[15] & 0x7; 5070 for( i=0; i< 15; i++ ) 5071 if ((UCaux3.e[i] & 0x7)!=b) 5072 err++; 5073 if (err) 5074 { 5075 printf("The three low-order bits of all byte elements in b must be the same\n"); 5076 printf("otherwise the value into d is undefined\n"); 5077 } 5078 else 5079 { 5080 UCaux = 0; 5081 for( i=0; i< 16; i++ ) 5082 { 5083 UCaux = UCaux | (UCaux2.e[i]>>b); 5084 if (UCaux != UCaux1.e[i]) 5085 err++; 5086 UCaux = UCaux2.e[i]<<(8-b); 5087 } 5088 if (err) 5089 printf("Function vec_srl [type unsigned char] ===> Error\n"); 5090 else 5091 printf("Function vec_srl [type unsigned char] ===> OK\n"); 5092 } 5093 5094 err = 0; 5095 Saux1.v = vec_srl( Scons1, UCcons2 ); 5096 Saux2.v = Scons1; 5097 UCaux3.v = UCcons2; 5098 b = UCaux3.e[15] & 0x7; 5099 for( i=0; i< 15; i++ ) 5100 if ((UCaux3.e[i] & 0x7)!=b) 5101 err++; 5102 if (err) 5103 { 5104 printf("The three low-order bits of all byte elements in b must be the same\n"); 5105 printf("otherwise the value into d is undefined\n"); 5106 } 5107 else 5108 { 5109 Saux = 0; 5110 for( i=0; i< 8; i++ ) 5111 { 5112 INTunion1.ss[0] = Saux2.e[i]; 5113 Saux = Saux | (INTunion1.us[0]>>b); 5114 if (Saux != Saux1.e[i]) 5115 err++; 5116 Saux = INTunion1.us[0]<<(16-b); 5117 } 5118 if (err) 5119 printf("Function vec_srl [type short] ===> Error\n"); 5120 else 5121 printf("Function vec_srl [type short] ===> OK\n"); 5122 } 5123 5124 err = 0; 5125 USaux1.v = vec_srl( UScons1, UCcons2 ); 5126 USaux2.v = UScons1; 5127 UCaux3.v = UCcons2; 5128 b = UCaux3.e[15] & 0x7; 5129 for( i=0; i< 15; i++ ) 5130 if ((UCaux3.e[i] & 0x7)!=b) 5131 err++; 5132 if (err) 5133 { 5134 printf("The three low-order bits of all byte elements in b must be the same\n"); 5135 printf("otherwise the value into d is undefined\n"); 5136 } 5137 else 5138 { 5139 USaux = 0; 5140 for( i=0; i< 8; i++ ) 5141 { 5142 USaux = USaux | (USaux2.e[i]>>b); 5143 if (USaux != USaux1.e[i]) 5144 err++; 5145 USaux = USaux2.e[i]<<(16-b); 5146 } 5147 if (err) 5148 printf("Function vec_srl [type unsigned short] ===> Error\n"); 5149 else 5150 printf("Function vec_srl [type unsigned short] ===> OK\n"); 5151 } 5152 5153 err = 0; 5154 Iaux1.v = vec_srl( Icons1, UCcons2 ); 5155 Iaux2.v = Icons1; 5156 UCaux3.v = UCcons2; 5157 b = UCaux3.e[15] & 0x7; 5158 for( i=0; i< 15; i++ ) 5159 if ((UCaux3.e[i] & 0x7)!=b) 5160 err++; 5161 if (err) 5162 { 5163 printf("The three low-order bits of all byte elements in b must be the same\n"); 5164 printf("otherwise the value into d is undefined\n"); 5165 } 5166 else 5167 { 5168 Iaux = 0; 5169 for( i=0; i< 4; i++ ) 5170 { 5171 INTunion1.si = Iaux2.e[i]; 5172 Iaux = Iaux | (INTunion1.ui>>b); 5173 if (Iaux != Iaux1.e[i]) 5174 err++; 5175 Iaux = INTunion1.ui<<(32-b); 5176 } 5177 if (err) 5178 printf("Function vec_srl [type integer] ===> Error\n"); 5179 else 5180 printf("Function vec_srl [type integer] ===> OK\n"); 5181 } 5182 5183 err = 0; 5184 UIaux1.v = vec_srl( UIcons1, UCcons2 ); 5185 UIaux2.v = UIcons1; 5186 UCaux3.v = UCcons2; 5187 b = UCaux3.e[15] & 0x7; 5188 for( i=0; i< 15; i++ ) 5189 if ((UCaux3.e[i] & 0x7)!=b) 5190 err++; 5191 if (err) 5192 { 5193 printf("The three low-order bits of all byte elements in b must be the same\n"); 5194 printf("otherwise the value into d is undefined\n"); 5195 } 5196 else 5197 { 5198 UIaux = 0; 5199 for( i=0; i< 4; i++ ) 5200 { 5201 UIaux = UIaux | (UIaux2.e[i]>>b); 5202 if (UIaux != UIaux1.e[i]) 5203 err++; 5204 UIaux = UIaux2.e[i]<<(32-b); 5205 } 5206 if (err) 5207 printf("Function vec_srl [type unsigned int] ===> Error\n"); 5208 else 5209 printf("Function vec_srl [type unsigned int] ===> OK\n"); 5210 } 5211 5212 /* Function vec_sro */ 5213 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 5214 err = 0; 5215 Caux1.v = vec_sro( Ccons3, Ccons1 ); 5216 Caux2.v = Ccons3; 5217 Caux3.v = Ccons1; 5218 b = (Caux3.e[15] & 0x78) >>3; 5219 for( i=0; i< 16; i++ ) 5220 { 5221 if ((i-b)>=0) 5222 { 5223 if (Caux1.e[i] != Caux2.e[i-b]) 5224 err++; 5225 } 5226 else 5227 { 5228 if (Caux1.e[i] != 0) 5229 err++; 5230 } 5231 } 5232 if (err) 5233 printf("Function vec_sro [type char] ===> Error\n"); 5234 else 5235 printf("Function vec_sro [type char] ===> OK\n"); 5236 5237 err = 0; 5238 UCaux1.v = vec_sro( UCcons3, UCcons1 ); 5239 UCaux2.v = UCcons3; 5240 UCaux3.v = UCcons1; 5241 b = (UCaux3.e[15] & 0x78) >>3; 5242 for( i=0; i< 16; i++ ) 5243 { 5244 if ((i-b)>=0) 5245 { 5246 if (UCaux1.e[i] != UCaux2.e[i-b]) 5247 err++; 5248 } 5249 else 5250 { 5251 if (UCaux1.e[i] != 0) 5252 err++; 5253 } 5254 } 5255 if (err) 5256 printf("Function vec_sro [type unsigned char] ===> Error\n"); 5257 else 5258 printf("Function vec_sro [type unsigned char] ===> OK\n"); 5259 5260 err = 0; 5261 Saux1.v = vec_sro( Scons3, Ccons1 ); 5262 Saux2.v = Scons3; 5263 Caux3.v = Ccons1; 5264 b = (Caux3.e[15] & 0x78) >>3; 5265 for( i=0; i< 16; i++ ) 5266 { 5267 SHOunion1.ss = Saux1.e[i/2]; 5268 if ((i-b)>=0) 5269 { 5270 SHOunion2.ss = Saux2.e[(i-b)/2]; 5271 if (SHOunion1.sc[i%2] != SHOunion2.sc[(i-b)%2]) 5272 err++; 5273 } 5274 else 5275 { 5276 if (SHOunion1.sc[i%2] != 0) 5277 err++; 5278 } 5279 } 5280 if (err) 5281 printf("Function vec_sro [type short] ===> Error\n"); 5282 else 5283 printf("Function vec_sro [type short] ===> OK\n"); 5284 5285 err = 0; 5286 USaux1.v = vec_sro( UScons3, UCcons1 ); 5287 USaux2.v = UScons3; 5288 UCaux3.v = UCcons1; 5289 b = (UCaux3.e[15] & 0x78) >>3; 5290 for( i=0; i< 16; i++ ) 5291 { 5292 SHOunion1.us = USaux1.e[i/2]; 5293 if ((i-b)>=0) 5294 { 5295 SHOunion2.us = USaux2.e[(i-b)/2]; 5296 if (SHOunion1.uc[i%2] != SHOunion2.uc[(i-b)%2]) 5297 err++; 5298 } 5299 else 5300 { 5301 if (SHOunion1.uc[i%2] != 0) 5302 err++; 5303 } 5304 } 5305 if (err) 5306 printf("Function vec_sro [type unsigned short] ===> Error\n"); 5307 else 5308 printf("Function vec_sro [type unsigned short] ===> OK\n"); 5309 5310 err = 0; 5311 Iaux1.v = vec_sro( Icons3, Ccons1 ); 5312 Iaux2.v = Icons3; 5313 Caux3.v = Ccons1; 5314 b = (Caux3.e[15] & 0x78) >>3; 5315 for( i=0; i< 16; i++ ) 5316 { 5317 INTunion1.si = Iaux1.e[i/4]; 5318 if ((i-b)>=0) 5319 { 5320 INTunion2.si = Iaux2.e[(i-b)/4]; 5321 if (INTunion1.sc[i%4] != INTunion2.sc[(i-b)%4]) 5322 err++; 5323 } 5324 else 5325 { 5326 if (INTunion1.sc[i%4] != 0) 5327 err++; 5328 } 5329 } 5330 if (err) 5331 printf("Function vec_sro [type integer] ===> Error\n"); 5332 else 5333 printf("Function vec_sro [type integer] ===> OK\n"); 5334 5335 err = 0; 5336 UIaux1.v = vec_sro( UIcons3, UCcons1 ); 5337 UIaux2.v = UIcons3; 5338 UCaux3.v = UCcons1; 5339 b = (UCaux3.e[15] & 0x78) >>3; 5340 for( i=0; i< 16; i++ ) 5341 { 5342 INTunion1.ui = UIaux1.e[i/4]; 5343 if ((i-b)>=0) 5344 { 5345 INTunion2.ui = UIaux2.e[(i-b)/4]; 5346 if (INTunion1.uc[i%4] != INTunion2.sc[(i-b)%4]) 5347 err++; 5348 } 5349 else 5350 { 5351 if (INTunion1.uc[i%4] != 0) 5352 err++; 5353 } 5354 } 5355 if (err) 5356 printf("Function vec_sro [type unsigned int] ===> Error\n"); 5357 else 5358 printf("Function vec_sro [type unsigned int] ===> OK\n"); 5359 5360 #if defined TEST_FLOATS 5361 err = 0; 5362 Faux1.v = vec_sro( Fcons3, Ccons1 ); 5363 Faux2.v = Fcons3; 5364 Caux3.v = Ccons1; 5365 b = (Caux3.e[15] & 0x78) >>3; 5366 for( i=0; i< 16; i++ ) 5367 { 5368 INTunion1.f = Faux1.e[i/4]; 5369 if ((i-b)>=0) 5370 { 5371 INTunion2.f = Faux2.e[(i-b)/4]; 5372 if (INTunion1.sc[i%4] != INTunion2.sc[(i-b)%4]) 5373 err++; 5374 } 5375 else 5376 { 5377 if (INTunion1.sc[i%4] != 0) 5378 err++; 5379 } 5380 } 5381 if (err) 5382 printf("Function vec_sro [type float] ===> Error\n"); 5383 else 5384 printf("Function vec_sro [type float] ===> OK\n"); 5385 #endif 5386 5387 /* Function vec_st */ 5388 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 5389 err = 0; 5390 UCaux1.v = UCcons1; 5391 vec_st( UCaux1.v, 0, UCmem ); 5392 Iaux = 1; 5393 for ( i=0; i< 16; i++ ) 5394 { 5395 Iaux = Iaux && (UCaux1.e[i]==UCmem[i]); 5396 } 5397 if (Iaux!=1) err++; 5398 5399 if (err) 5400 printf("Function vec_st [type unsigned char] ===> Error\n"); 5401 else 5402 printf("Function vec_st [type unsigned char] ===> OK\n"); 5403 5404 err = 0; 5405 Caux1.v = Ccons1; 5406 vec_st( Caux1.v, 0, Cmem ); 5407 Iaux = 1; 5408 for ( i=0; i< 16; i++ ) 5409 { 5410 Iaux = Iaux && (Caux1.e[i]==Cmem[i]); 5411 } 5412 if (Iaux!=1) err++; 5413 5414 if (err) 5415 printf("Function vec_st [type char] ===> Error\n"); 5416 else 5417 printf("Function vec_st [type char] ===> OK\n"); 5418 5419 err = 0; 5420 USaux1.v = UScons3; 5421 vec_st( USaux1.v, 0, USmem ); 5422 Iaux = 1; 5423 for ( i=0; i< 8; i++ ) 5424 { 5425 Iaux = Iaux && (USaux1.e[i]==USmem[i]); 5426 } 5427 if (Iaux!=1) err++; 5428 5429 if (err) 5430 printf("Function vec_st [type unsigned short] ===> Error\n"); 5431 else 5432 printf("Function vec_st [type unsigned short] ===> OK\n"); 5433 5434 err = 0; 5435 Saux1.v = Scons1; 5436 vec_st( Saux1.v, 0, Smem ); 5437 Iaux = 1; 5438 for ( i=0; i< 8; i++ ) 5439 { 5440 Iaux = Iaux && (Saux1.e[i]==Smem[i]); 5441 } 5442 if (Iaux!=1) err++; 5443 5444 if (err) 5445 printf("Function vec_st [type short] ===> Error\n"); 5446 else 5447 printf("Function vec_st [type short] ===> OK\n"); 5448 5449 err = 0; 5450 UIaux1.v = UIcons1; 5451 vec_st( UIaux1.v, 0, UImem ); 5452 Iaux = 1; 5453 for ( i=0; i< 4; i++ ) 5454 { 5455 Iaux = Iaux && (UIaux1.e[i]==UImem[i]); 5456 } 5457 if (Iaux!=1) err++; 5458 5459 if (err) 5460 printf("Function vec_st [type unsigned int] ===> Error\n"); 5461 else 5462 printf("Function vec_st [type unsigned int] ===> OK\n"); 5463 5464 err = 0; 5465 Iaux1.v = Icons1; 5466 vec_st( Iaux1.v, 0, Imem ); 5467 Iaux = 1; 5468 for ( i=0; i< 4; i++ ) 5469 { 5470 Iaux = Iaux && (Iaux1.e[i]==Imem[i]); 5471 } 5472 if (Iaux!=1) err++; 5473 5474 if (err) 5475 printf("Function vec_st [type int] ===> Error\n"); 5476 else 5477 printf("Function vec_st [type int] ===> OK\n"); 5478 5479 #if defined TEST_FLOATS 5480 err = 0; 5481 Faux1.v = Fcons1; 5482 vec_st( Faux1.v, 0, Fmem ); 5483 Iaux = 1; 5484 for ( i=0; i< 4; i++ ) 5485 { 5486 Iaux = Iaux && (Faux1.e[i]==Fmem[i]); 5487 } 5488 if (Iaux!=1) err++; 5489 5490 if (err) 5491 printf("Function vec_st [type float] ===> Error\n"); 5492 else 5493 printf("Function vec_st [type float] ===> OK\n"); 5494 #endif 5495 5496 /* Function vec_ste */ 5497 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 5498 err = 0; 5499 b = 11; 5500 UCaux1.v = UCcons1; 5501 vec_ste( UCaux1.v, b, UCmem ); 5502 i = b; 5503 if (UCaux1.e[i]!=UCmem[i]) err++; 5504 5505 if (err) 5506 printf("Function vec_ste [type unsigned char] ===> Error\n"); 5507 else 5508 printf("Function vec_ste [type unsigned char] ===> OK\n"); 5509 5510 err = 0; 5511 b = 11; 5512 Caux1.v = Ccons1; 5513 vec_ste( Caux1.v, b, Cmem ); 5514 i = b; 5515 if (Caux1.e[i]!=Cmem[i]) err++; 5516 5517 if (err) 5518 printf("Function vec_ste [type char] ===> Error\n"); 5519 else 5520 printf("Function vec_ste [type char] ===> OK\n"); 5521 5522 err = 0; 5523 b = 11; 5524 USaux1.v = UScons1; 5525 vec_ste( USaux1.v, b, USmem ); 5526 i = b/2; 5527 if (USaux1.e[i]!=USmem[i]) err++; 5528 if (err) 5529 printf("Function vec_ste [type unsigned short] ===> Error\n"); 5530 else 5531 printf("Function vec_ste [type unsigned short] ===> OK\n"); 5532 5533 err = 0; 5534 b = 11; 5535 Saux1.v = Scons1; 5536 vec_ste( Saux1.v, b, Smem ); 5537 i = b/2; 5538 if (Saux1.e[i]!=Smem[i]) err++; 5539 if (err) 5540 printf("Function vec_ste [type short] ===> Error\n"); 5541 else 5542 printf("Function vec_ste [type short] ===> OK\n"); 5543 5544 err = 0; 5545 b = 11; 5546 UIaux1.v = UIcons1; 5547 vec_ste( UIaux1.v, b, UImem ); 5548 i = b/4; 5549 if (UIaux1.e[i]!=UImem[i]) err++; 5550 if (err) 5551 printf("Function vec_ste [type unsigned int] ===> Error\n"); 5552 else 5553 printf("Function vec_ste [type unsigned int] ===> OK\n"); 5554 5555 err = 0; 5556 b = 11; 5557 Iaux1.v = Icons1; 5558 vec_ste( Iaux1.v, b, Imem ); 5559 i = b/4; 5560 if (Iaux1.e[i]!=Imem[i]) err++; 5561 if (err) 5562 printf("Function vec_ste [type int] ===> Error\n"); 5563 else 5564 printf("Function vec_ste [type int] ===> OK\n"); 5565 5566 #if defined TEST_FLOATS 5567 err = 0; 5568 b = 11; 5569 Faux1.v = Fcons1; 5570 vec_ste( Faux1.v, b, Fmem ); 5571 i = b/4; 5572 if (Faux1.e[i]!=Fmem[i]) err++; 5573 if (err) 5574 printf("Function vec_ste [type float] ===> Error\n"); 5575 else 5576 printf("Function vec_ste [type float] ===> OK\n"); 5577 #endif 5578 5579 #if 0 5580 /* Function vec_stl */ 5581 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 5582 err = 0; 5583 UCaux1.v = UCcons1; 5584 vec_stl( UCaux1.v, 0, UCmem ); 5585 Iaux = 1; 5586 for ( i=0; i< 16; i++ ) 5587 { 5588 Iaux = Iaux && (UCaux1.e[i]==UCmem[i]); 5589 } 5590 if (Iaux!=1) err++; 5591 5592 if (err) 5593 printf("Function vec_stl [type unsigned char] ===> Error\n"); 5594 else 5595 printf("Function vec_stl [type unsigned char] ===> OK\n"); 5596 5597 err = 0; 5598 Caux1.v = Ccons1; 5599 vec_stl( Caux1.v, 0, Cmem ); 5600 Iaux = 1; 5601 for ( i=0; i< 16; i++ ) 5602 { 5603 Iaux = Iaux && (Caux1.e[i]==Cmem[i]); 5604 } 5605 if (Iaux!=1) err++; 5606 5607 if (err) 5608 printf("Function vec_stl [type char] ===> Error\n"); 5609 else 5610 printf("Function vec_stl [type char] ===> OK\n"); 5611 5612 err = 0; 5613 USaux1.v = UScons3; 5614 vec_stl( USaux1.v, 0, USmem ); 5615 Iaux = 1; 5616 for ( i=0; i< 8; i++ ) 5617 { 5618 Iaux = Iaux && (USaux1.e[i]==USmem[i]); 5619 } 5620 if (Iaux!=1) err++; 5621 5622 if (err) 5623 printf("Function vec_stl [type unsigned short] ===> Error\n"); 5624 else 5625 printf("Function vec_stl [type unsigned short] ===> OK\n"); 5626 5627 err = 0; 5628 Saux1.v = Scons1; 5629 vec_stl( Saux1.v, 0, Smem ); 5630 Iaux = 1; 5631 for ( i=0; i< 8; i++ ) 5632 { 5633 Iaux = Iaux && (Saux1.e[i]==Smem[i]); 5634 } 5635 if (Iaux!=1) err++; 5636 5637 if (err) 5638 printf("Function vec_stl [type short] ===> Error\n"); 5639 else 5640 printf("Function vec_stl [type short] ===> OK\n"); 5641 5642 err = 0; 5643 UIaux1.v = UIcons1; 5644 vec_stl( UIaux1.v, 0, UImem ); 5645 Iaux = 1; 5646 for ( i=0; i< 4; i++ ) 5647 { 5648 Iaux = Iaux && (UIaux1.e[i]==UImem[i]); 5649 } 5650 if (Iaux!=1) err++; 5651 5652 if (err) 5653 printf("Function vec_stl [type unsigned int] ===> Error\n"); 5654 else 5655 printf("Function vec_stl [type unsigned int] ===> OK\n"); 5656 5657 err = 0; 5658 Iaux1.v = Icons1; 5659 vec_stl( Iaux1.v, 0, Imem ); 5660 Iaux = 1; 5661 for ( i=0; i< 4; i++ ) 5662 { 5663 Iaux = Iaux && (Iaux1.e[i]==Imem[i]); 5664 } 5665 if (Iaux!=1) err++; 5666 5667 if (err) 5668 printf("Function vec_stl [type int] ===> Error\n"); 5669 else 5670 printf("Function vec_stl [type int] ===> OK\n"); 5671 5672 #if defined TEST_FLOATS 5673 err = 0; 5674 Faux1.v = Fcons1; 5675 vec_stl( Faux1.v, 0, Fmem ); 5676 Iaux = 1; 5677 for ( i=0; i< 4; i++ ) 5678 { 5679 Iaux = Iaux && (Faux1.e[i]==Fmem[i]); 5680 } 5681 if (Iaux!=1) err++; 5682 5683 if (err) 5684 printf("Function vec_stl [type float] ===> Error\n"); 5685 else 5686 printf("Function vec_stl [type float] ===> OK\n"); 5687 #endif 5688 #endif // #if 0 5689 5690 /* Free dynamic vector variables */ 5691 free_vec( UCmem ); 5692 free_vec( Cmem ); 5693 free_vec( USmem ); 5694 free_vec( Smem ); 5695 free_vec( UImem ); 5696 free_vec( Imem ); 5697 #if defined TEST_FLOATS 5698 free_vec( Fmem ); 5699 #endif 5700 5701 return 0; 5702 } 5703 5704 5705 5706 5707 int part4( ) 5708 { 5709 TvecChar Caux1, Caux2, Caux3;//, Caux4; 5710 TvecUChar UCaux1, UCaux2, UCaux3;//, UCaux4; 5711 TvecShort Saux1, Saux2, Saux3;//, Saux4; 5712 TvecUShort USaux1, USaux2, USaux3;//, USaux4; 5713 TvecInt Iaux1, Iaux2, Iaux3;//, Iaux4; 5714 TvecUInt UIaux1, UIaux2, UIaux3;//, UIaux4; 5715 #if defined TEST_FLOATS 5716 TvecFloat Faux1, Faux2, Faux3;//, Faux4; 5717 #endif 5718 5719 int i, err, j;//, b, bAux; 5720 // signed int Ivec1, Ivec2, Ivec3; 5721 // signed short *Svec1; 5722 // unsigned int *UIvec1; 5723 // unsigned short *USvec1; 5724 // unsigned char *UCvec1; 5725 #if defined TEST_FLOATS 5726 // float *Fvec1; 5727 #endif 5728 5729 /* For saturated rutines */ 5730 long long int LLaux; 5731 5732 #if defined TEST_FLOATS 5733 float Faux; 5734 #endif 5735 signed int Iaux;//, I1, I2; 5736 unsigned int UIaux;//, UI1, UI2; 5737 signed short Saux; 5738 unsigned short USaux; 5739 signed char Caux; 5740 unsigned char UCaux; 5741 5742 /* 5743 union 5744 { 5745 float f; 5746 signed int si; 5747 unsigned int ui; 5748 signed short ss[2]; 5749 unsigned short us[2]; 5750 signed char sc[4]; 5751 unsigned char uc[4]; 5752 } INTunion1, INTunion2; 5753 5754 union 5755 { 5756 signed short ss; 5757 unsigned short us; 5758 signed char sc[2]; 5759 unsigned char uc[2]; 5760 } SHOunion1, SHOunion2; 5761 */ 5762 5763 #if defined (GCC_COMPILER) 5764 vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 5765 vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 5766 vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127}; 5767 vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7}; 5768 vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; 5769 vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}; 5770 vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3}; 5771 vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000}; 5772 vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767}; 5773 vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3}; 5774 vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1}; 5775 vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4}; 5776 vector signed int Icons1 = (vector signed int){-4, -1, 1, 4}; 5777 vector signed int Icons2 = (vector signed int){1, 1, 1, 1}; 5778 vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF}; 5779 vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1}; 5780 vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1}; 5781 vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2}; 5782 5783 #if defined TEST_FLOATS 5784 vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999}; 5785 vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0}; 5786 vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0}; 5787 #endif 5788 5789 #elif defined (MAC_COMPILER) || defined(XLC_COMPILER) 5790 vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 5791 vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); 5792 vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127); 5793 vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7); 5794 vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2); 5795 vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8); 5796 vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3); 5797 vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000); 5798 vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767); 5799 vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3); 5800 vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1); 5801 vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4); 5802 vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4); 5803 vector signed int Icons2 = (vector signed int)(1, 1, 1, 1); 5804 vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF); 5805 vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1); 5806 vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1); 5807 vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2); 5808 5809 #if defined TEST_FLOATS 5810 vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999); 5811 vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0); 5812 vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0); 5813 #endif 5814 5815 #endif 5816 5817 5818 /* Function vec_sub */ 5819 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 5820 err = 0; 5821 Caux1.v = vec_sub( Ccons1, Ccons2 ); 5822 Caux2.v = Ccons1; 5823 Caux3.v = Ccons2; 5824 for( i=0; i< 16; i++ ) 5825 { 5826 Caux = Caux2.e[i] - Caux3.e[i]; 5827 if (Caux1.e[i] != Caux) 5828 err++; 5829 } 5830 if (err) 5831 printf("Function vec_sub [type char] ===> Error\n"); 5832 else 5833 printf("Function vec_sub [type char] ===> OK\n"); 5834 5835 err = 0; 5836 UCaux1.v = vec_sub( UCcons1, UCcons2 ); 5837 UCaux2.v = UCcons1; 5838 UCaux3.v = UCcons2; 5839 for( i=0; i< 16; i++ ) 5840 { 5841 UCaux = UCaux2.e[i] - UCaux3.e[i]; 5842 if (UCaux1.e[i] != UCaux) 5843 err++; 5844 } 5845 if (err) 5846 printf("Function vec_sub [type unsigned char] ===> Error\n"); 5847 else 5848 printf("Function vec_sub [type unsigned char] ===> OK\n"); 5849 5850 err = 0; 5851 Saux1.v = vec_sub( Scons1, Scons2 ); 5852 Saux2.v = Scons1; 5853 Saux3.v = Scons2; 5854 for( i=0; i< 8; i++ ) 5855 { 5856 Saux = Saux2.e[i] - Saux3.e[i]; 5857 if (Saux1.e[i] != Saux) 5858 err++; 5859 } 5860 if (err) 5861 printf("Function vec_sub [type short] ===> Error\n"); 5862 else 5863 printf("Function vec_sub [type short] ===> OK\n"); 5864 5865 err = 0; 5866 USaux1.v = vec_sub( UScons1, UScons2 ); 5867 USaux2.v = UScons1; 5868 USaux3.v = UScons2; 5869 for( i=0; i< 8; i++ ) 5870 { 5871 USaux = USaux2.e[i] - USaux3.e[i]; 5872 if (USaux1.e[i] != USaux) 5873 err++; 5874 } 5875 if (err) 5876 printf("Function vec_sub [type unsigned short] ===> Error\n"); 5877 else 5878 printf("Function vec_sub [type unsigned short] ===> OK\n"); 5879 5880 err = 0; 5881 Iaux1.v = vec_sub( Icons1, Icons2 ); 5882 Iaux2.v = Icons1; 5883 Iaux3.v = Icons2; 5884 for( i=0; i< 4; i++ ) 5885 { 5886 Iaux = Iaux2.e[i] - Iaux3.e[i]; 5887 if (Iaux1.e[i] != Iaux) 5888 err++; 5889 } 5890 if (err) 5891 printf("Function vec_sub [type integer] ===> Error\n"); 5892 else 5893 printf("Function vec_sub [type integer] ===> OK\n"); 5894 5895 err = 0; 5896 UIaux1.v = vec_sub( UIcons1, UIcons2 ); 5897 UIaux2.v = UIcons1; 5898 UIaux3.v = UIcons2; 5899 for( i=0; i< 4; i++ ) 5900 { 5901 UIaux = UIaux2.e[i] - UIaux3.e[i]; 5902 if (UIaux1.e[i] != UIaux) 5903 err++; 5904 } 5905 if (err) 5906 printf("Function vec_sub [type unsigned int] ===> Error\n"); 5907 else 5908 printf("Function vec_sub [type unsigned int] ===> OK\n"); 5909 5910 #if defined TEST_FLOATS 5911 err = 0; 5912 Faux1.v = vec_sub( Fcons1, Fcons2 ); 5913 Faux2.v = Fcons1; 5914 Faux3.v = Fcons2; 5915 for( i=0; i< 4; i++ ) 5916 { 5917 Faux = Faux2.e[i] - Faux3.e[i]; 5918 if (Faux1.e[i] != Faux) 5919 err++; 5920 } 5921 if (err) 5922 printf("Function vec_sub [type float] ===> Error\n"); 5923 else 5924 printf("Function vec_sub [type float] ===> OK\n"); 5925 #endif 5926 5927 /* Function vec_subc */ 5928 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 5929 err = 0; 5930 UIaux1.v = vec_subc( UIcons2, UIcons3 ); 5931 UIaux2.v = UIcons2; 5932 UIaux3.v = UIcons3; 5933 for( i=0; i< 4; i++ ) 5934 { 5935 if (UIaux3.e[i]>UIaux2.e[i]) 5936 { 5937 if (UIaux1.e[i] != 0) 5938 err++; 5939 } 5940 else 5941 { 5942 if (UIaux1.e[i] != 1) 5943 err++; 5944 } 5945 } 5946 if (err) 5947 printf("Function vec_subc [type unsigned int] ===> Error\n"); 5948 else 5949 printf("Function vec_subc [type unsigned int] ===> OK\n"); 5950 5951 /* Function vec_subs */ 5952 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 5953 err = 0; 5954 Caux1.v = vec_subs( Ccons1, Ccons3 ); 5955 Caux2.v = Ccons1; 5956 Caux3.v = Ccons3; 5957 for( i=0; i< 16; i++ ) 5958 { 5959 Caux = (signed char)Caux2.e[i]-Caux3.e[i]; 5960 if ((Caux2.e[i]>=0)&&(Caux3.e[i]<0)) 5961 { 5962 if (Caux< Caux2.e[i]) 5963 Caux=0x7F; 5964 } 5965 else if ((Caux2.e[i]<0)&&(Caux3.e[i]>0)) 5966 { 5967 if (Caux> Caux2.e[i]) 5968 Caux=0x80; 5969 } 5970 if (Caux1.e[i] != Caux) 5971 err++; 5972 } 5973 if (err) 5974 printf("Function vec_subs [type char] ===> Error\n"); 5975 else 5976 printf("Function vec_subs [type char] ===> OK\n"); 5977 5978 err = 0; 5979 UCaux1.v = vec_subs( UCcons1, UCcons3 ); 5980 UCaux2.v = UCcons1; 5981 UCaux3.v = UCcons3; 5982 for( i=0; i< 16; i++ ) 5983 { 5984 UCaux = (unsigned char)(UCaux2.e[i]-UCaux3.e[i]); 5985 if (UCaux> UCaux2.e[i]) 5986 UCaux=0; 5987 if (UCaux1.e[i] != UCaux) 5988 err++; 5989 } 5990 if (err) 5991 printf("Function vec_subs [type unsigned char] ===> Error\n"); 5992 else 5993 printf("Function vec_subs [type unsigned char] ===> OK\n"); 5994 5995 err = 0; 5996 Saux1.v = vec_subs( Scons1, Scons3 ); 5997 Saux2.v = Scons1; 5998 Saux3.v = Scons3; 5999 for( i=0; i< 8; i++ ) 6000 { 6001 Saux = (signed short)(Saux2.e[i] - Saux3.e[i]); 6002 if ((Saux2.e[i]>=0)&&(Saux3.e[i]<0)) 6003 { 6004 if (Saux< Saux2.e[i]) 6005 Saux=0x7FFF; 6006 } 6007 else if ((Saux2.e[i]<0)&&(Saux3.e[i]>0)) 6008 { 6009 if (Saux> Saux2.e[i]) 6010 Saux=0x8000; 6011 } 6012 if (Saux1.e[i] != Saux) 6013 err++; 6014 } 6015 if (err) 6016 printf("Function vec_subs [type short] ===> Error\n"); 6017 else 6018 printf("Function vec_subs [type short] ===> OK\n"); 6019 6020 err = 0; 6021 USaux1.v = vec_subs( UScons1, UScons3 ); 6022 USaux2.v = UScons1; 6023 USaux3.v = UScons3; 6024 for( i=0; i< 8; i++ ) 6025 { 6026 USaux = (unsigned short)(USaux2.e[i] - USaux3.e[i]); 6027 if (USaux> USaux2.e[i]) 6028 USaux=0x0; 6029 if (USaux1.e[i] != USaux) 6030 err++; 6031 } 6032 if (err) 6033 printf("Function vec_subs [type unsigned short] ===> Error\n"); 6034 else 6035 printf("Function vec_subs [type unsigned short] ===> OK\n"); 6036 6037 6038 err = 0; 6039 Iaux1.v = vec_subs( Icons1, Icons3 ); 6040 Iaux2.v = Icons1; 6041 Iaux3.v = Icons3; 6042 for( i=0; i< 4; i++ ) 6043 { 6044 Iaux = (signed int)(Iaux2.e[i] - Iaux3.e[i]); 6045 if ((Iaux2.e[i]>=0)&&(Iaux3.e[i]<0)) 6046 { 6047 if (Iaux< Iaux2.e[i]) 6048 Iaux=0x7FFFFFFF; 6049 } 6050 else if ((Iaux2.e[i]<0)&&(Iaux3.e[i]>0)) 6051 { 6052 if (Iaux> Iaux2.e[i]) 6053 { 6054 printf("%d > %d\n", Iaux, Iaux2.e[i]); 6055 Iaux=0x80000000; 6056 } 6057 } 6058 if (Iaux1.e[i] != Iaux) 6059 err++; 6060 } 6061 if (err) 6062 printf("Function vec_subs [type integer] ===> Error\n"); 6063 else 6064 printf("Function vec_subs [type integer] ===> OK\n"); 6065 6066 err = 0; 6067 UIaux1.v = vec_subs( UIcons1, UIcons3 ); 6068 UIaux2.v = UIcons1; 6069 UIaux3.v = UIcons3; 6070 for( i=0; i< 4; i++ ) 6071 { 6072 UIaux = (unsigned int)(UIaux2.e[i] - UIaux3.e[i]); 6073 if (UIaux> UIaux2.e[i]) 6074 UIaux=0x0; 6075 if (UIaux1.e[i] != UIaux) 6076 err++; 6077 } 6078 if (err) 6079 printf("Function vec_subs [type unsigned int] ===> Error\n"); 6080 else 6081 printf("Function vec_subs [type unsigned int] ===> OK\n"); 6082 6083 /* Function vec_sum4s */ 6084 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6085 err = 0; 6086 Iaux1.v = vec_sum4s( Ccons2, Icons2 ); 6087 Caux1.v = Ccons2; 6088 Iaux2.v = Icons2; 6089 for( i=0; i< 4; i++ ) 6090 { 6091 Iaux = Iaux2.e[i]; 6092 for( j=0; j< 4; j++ ) 6093 Iaux = Iaux + Caux1.e[4*i+j]; 6094 if (Iaux1.e[i] != Iaux) 6095 err++; 6096 } 6097 if (err) 6098 printf("Function vec_sum4s [type char] ===> Error\n"); 6099 else 6100 printf("Function vec_sum4s [type char] ===> OK\n"); 6101 6102 err = 0; 6103 UIaux1.v = vec_sum4s( UCcons2, UIcons2 ); 6104 UCaux1.v = UCcons2; 6105 UIaux2.v = UIcons2; 6106 for( i=0; i< 4; i++ ) 6107 { 6108 UIaux = UIaux2.e[i]; 6109 for( j=0; j< 4; j++ ) 6110 UIaux = UIaux + UCaux1.e[4*i+j]; 6111 if (UIaux1.e[i] != UIaux) 6112 err++; 6113 } 6114 if (err) 6115 printf("Function vec_sum4s [type unsigned char] ===> Error\n"); 6116 else 6117 printf("Function vec_sum4s [type unsigned char] ===> OK\n"); 6118 6119 err = 0; 6120 Iaux1.v = vec_sum4s( Scons2, Icons2 ); 6121 Saux1.v = Scons2; 6122 Iaux2.v = Icons2; 6123 for( i=0; i< 4; i++ ) 6124 { 6125 Iaux = Iaux2.e[i]; 6126 for( j=0; j< 2; j++ ) 6127 Iaux = Iaux + Saux1.e[2*i+j]; 6128 if (Iaux1.e[i] != Iaux) 6129 err++; 6130 } 6131 if (err) 6132 printf("Function vec_sum4s [type short] ===> Error\n"); 6133 else 6134 printf("Function vec_sum4s [type short] ===> OK\n"); 6135 6136 /* Function vec_sum2s */ 6137 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6138 err = 0; 6139 Iaux1.v = Icons1; 6140 Iaux2.v = Icons3; 6141 Iaux3.v = vec_sum2s( Iaux1.v, Iaux2.v ); 6142 for( i=0; i< 2; i++ ) 6143 { 6144 LLaux = (long long int) Iaux1.e[2*i] + Iaux1.e[(2*i)+1] + Iaux2.e[(2*i)+1]; 6145 if (LLaux > INT_MAX) 6146 { 6147 Iaux=0x7FFFFFFF; /* INT_MAX */ 6148 } 6149 else if (LLaux < INT_MIN) 6150 { 6151 Iaux=0x80000000; /* INT_MIN */ 6152 } 6153 else Iaux = (signed int) LLaux; 6154 6155 if ((Iaux3.e[2*i] != 0) || (Iaux3.e[(2*i)+1] != Iaux)) 6156 err++; 6157 } 6158 if (err) 6159 printf("Function vec_sum2s [type integer] ===> Error\n"); 6160 else 6161 printf("Function vec_sum2s [type integer] ===> OK\n"); 6162 6163 /* Function vec_sums */ 6164 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6165 err = 0; 6166 6167 /* Not saturated test */ 6168 Iaux1.v = Icons1; 6169 Iaux2.v = Icons3; 6170 Iaux3.v = vec_sums( Iaux1.v, Iaux2.v ); 6171 6172 LLaux = (long long int) Iaux1.e[0] + Iaux1.e[1] + Iaux1.e[2] + Iaux1.e[3] + Iaux2.e[3]; 6173 if (LLaux > INT_MAX) 6174 { 6175 Iaux=0x7FFFFFFF; /* INT_MAX */ 6176 } 6177 else if (LLaux < INT_MIN) 6178 { 6179 Iaux=0x80000000; /* INT_MIN */ 6180 } 6181 else Iaux = (signed int) LLaux; 6182 6183 if ((Iaux3.e[0] != 0) || (Iaux3.e[1] != 0) || (Iaux3.e[2] != 0) || 6184 (Iaux3.e[3] != Iaux)) 6185 err++; 6186 6187 /* Saturated test */ 6188 Iaux1.v = Icons2; 6189 Iaux2.v = Icons3; 6190 Iaux3.v = vec_sums( Iaux1.v, Iaux2.v ); 6191 6192 LLaux = (long long int) Iaux1.e[0] + Iaux1.e[1] + Iaux1.e[2] + Iaux1.e[3] + Iaux2.e[3]; 6193 if (LLaux > INT_MAX) 6194 { 6195 Iaux=0x7FFFFFFF; /* INT_MAX */ 6196 } 6197 else if (LLaux < INT_MIN) 6198 { 6199 Iaux=0x80000000; /* INT_MIN */ 6200 } 6201 else Iaux = (signed int) LLaux; 6202 6203 if ((Iaux3.e[0] != 0) || (Iaux3.e[1] != 0) || (Iaux3.e[2] != 0) || 6204 (Iaux3.e[3] != Iaux)) 6205 err++; 6206 6207 if (err) 6208 printf("Function vec_sums [type integer] ===> Error\n"); 6209 else 6210 printf("Function vec_sums [type integer] ===> OK\n"); 6211 6212 #if defined TEST_FLOATS 6213 /* Function vec_trunc */ 6214 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6215 err = 0; 6216 Faux1.v = Fcons1; 6217 Faux2.v = vec_trunc( Faux1.v ); 6218 for( i=0; i< 4; i++ ) 6219 { 6220 Faux = truncf(Faux1.e[i]); 6221 if (Faux2.e[i] != Faux) 6222 err++; 6223 } 6224 if (err) 6225 printf("Function vec_trunc [type float] ===> Error\n"); 6226 else 6227 printf("Function vec_trunc [type float] ===> OK\n"); 6228 #endif 6229 6230 /* Function vec_unpackh */ 6231 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6232 err = 0; 6233 Caux1.v = Ccons1; 6234 Saux1.v = vec_unpackh( Caux1.v ); 6235 for ( i=0; i< 8; i++ ) 6236 { 6237 Saux = (signed short)Caux1.e[i]; 6238 if (Saux1.e[i] != Saux) 6239 err++; 6240 } 6241 6242 if (err) 6243 printf("Function vec_unpackh [type short-char] ===> Error\n"); 6244 else 6245 printf("Function vec_unpackh [type short-char] ===> OK\n"); 6246 6247 err = 0; 6248 Saux1.v = Scons3; 6249 Iaux1.v = vec_unpackh( Saux1.v ); 6250 for ( i=0; i< 4; i++ ) 6251 { 6252 Iaux = (signed int)Saux1.e[i]; 6253 if (Iaux1.e[i] != Iaux) 6254 err++; 6255 } 6256 6257 if (err) 6258 printf("Function vec_unpackh [type int-short] ===> Error\n"); 6259 else 6260 printf("Function vec_unpackh [type int-short] ===> OK\n"); 6261 6262 /* Function vec_unpackl */ 6263 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6264 err = 0; 6265 Caux1.v = Ccons3; 6266 Saux1.v = vec_unpackl( Caux1.v ); 6267 for ( i=0; i< 8; i++ ) 6268 { 6269 Saux = (signed short)Caux1.e[i+8]; 6270 if (Saux1.e[i] != Saux) 6271 err++; 6272 } 6273 6274 if (err) 6275 printf("Function vec_unpackl [type short-char] ===> Error\n"); 6276 else 6277 printf("Function vec_unpackl [type short-char] ===> OK\n"); 6278 6279 err = 0; 6280 Saux1.v = Scons1; 6281 Iaux1.v = vec_unpackl( Saux1.v ); 6282 for ( i=0; i< 4; i++ ) 6283 { 6284 Iaux = (signed int)Saux1.e[i+4]; 6285 if (Iaux1.e[i] != Iaux) 6286 err++; 6287 } 6288 6289 if (err) 6290 printf("Function vec_unpackl [type int-short] ===> Error\n"); 6291 else 6292 printf("Function vec_unpackl [type int-short] ===> OK\n"); 6293 6294 /* Function vec_xor */ 6295 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6296 err = 0; 6297 UCaux1.v = UCcons1; 6298 UCaux2.v = UCcons3; 6299 UCaux3.v = vec_xor( UCaux1.v, UCaux2.v ); 6300 for( i=0; i< 16; i++ ) 6301 { 6302 UCaux = UCaux1.e[i] ^ UCaux2.e[i]; 6303 if (UCaux3.e[i] != UCaux) 6304 err++; 6305 } 6306 if (err) 6307 printf("Function vec_xor [type unsigned char] ===> Error\n"); 6308 else 6309 printf("Function vec_xor [type unsigned char] ===> OK\n"); 6310 6311 err = 0; 6312 Caux1.v = Ccons1; 6313 Caux2.v = Ccons3; 6314 Caux3.v = vec_xor( Caux1.v, Caux2.v ); 6315 for( i=0; i< 16; i++ ) 6316 { 6317 Caux = Caux1.e[i] ^ Caux2.e[i]; 6318 if (Caux3.e[i] != Caux) 6319 err++; 6320 } 6321 if (err) 6322 printf("Function vec_xor [type char] ===> Error\n"); 6323 else 6324 printf("Function vec_xor [type char] ===> OK\n"); 6325 6326 err = 0; 6327 USaux1.v = UScons1; 6328 USaux2.v = UScons3; 6329 USaux3.v = vec_xor( USaux1.v, USaux2.v ); 6330 for( i=0; i< 8; i++ ) 6331 { 6332 USaux = USaux1.e[i] ^ USaux2.e[i]; 6333 if (USaux3.e[i] != USaux) 6334 err++; 6335 } 6336 if (err) 6337 printf("Function vec_xor [type unsigned short] ===> Error\n"); 6338 else 6339 printf("Function vec_xor [type unsigned short] ===> OK\n"); 6340 6341 err = 0; 6342 Saux1.v = Scons1; 6343 Saux2.v = Scons3; 6344 Saux3.v = vec_xor( Saux1.v, Saux2.v ); 6345 for( i=0; i< 8; i++ ) 6346 { 6347 Saux = Saux1.e[i] ^ Saux2.e[i]; 6348 if (Saux3.e[i] != Saux) 6349 err++; 6350 } 6351 if (err) 6352 printf("Function vec_xor [type short] ===> Error\n"); 6353 else 6354 printf("Function vec_xor [type short] ===> OK\n"); 6355 6356 err = 0; 6357 UIaux1.v = UIcons1; 6358 UIaux2.v = UIcons3; 6359 UIaux3.v = vec_xor( UIaux1.v, UIaux2.v ); 6360 for( i=0; i< 4; i++ ) 6361 { 6362 UIaux = UIaux1.e[i] ^ UIaux2.e[i]; 6363 if (UIaux3.e[i] != UIaux) 6364 err++; 6365 } 6366 if (err) 6367 printf("Function vec_xor [type unsigned int] ===> Error\n"); 6368 else 6369 printf("Function vec_xor [type unsigned int] ===> OK\n"); 6370 6371 err = 0; 6372 Iaux1.v = Icons1; 6373 Iaux2.v = Icons3; 6374 Iaux3.v = vec_xor( Iaux1.v, Iaux2.v ); 6375 for( i=0; i< 4; i++ ) 6376 { 6377 Iaux = Iaux1.e[i] ^ Iaux2.e[i]; 6378 if (Iaux3.e[i] != Iaux) 6379 err++; 6380 } 6381 if (err) 6382 printf("Function vec_xor [type int] ===> Error\n"); 6383 else 6384 printf("Function vec_xor [type int] ===> OK\n"); 6385 6386 #if defined TEST_FLOATS 6387 err = 0; 6388 Faux1.v = Fcons1; 6389 Faux2.v = Fcons3; 6390 Faux3.v = vec_xor( Faux1.v, Faux2.v ); 6391 for( i=0; i< 4; i++ ) 6392 { 6393 Iaux = Faux1.i[i] ^ Faux2.i[i]; 6394 6395 if (Faux3.i[i] != Iaux) 6396 err++; 6397 } 6398 if (err) 6399 printf("Function vec_xor [type float] ===> Error\n"); 6400 else 6401 printf("Function vec_xor [type float] ===> OK\n"); 6402 #endif 6403 6404 return 0; 6405 } 6406 6407 6408 6409 6410 int part5() 6411 { 6412 TvecChar Caux1, Caux2;//, Caux3, Caux4; 6413 TvecUChar UCaux1, UCaux2;//, UCaux3, UCaux4; 6414 TvecShort Saux1, Saux2;//, Saux3, Saux4; 6415 TvecUShort USaux1, USaux2;//, USaux3, USaux4; 6416 TvecInt Iaux1, Iaux2;//, Iaux3, Iaux4; 6417 TvecUInt UIaux1, UIaux2;//, UIaux3, UIaux4; 6418 #if defined TEST_FLOATS 6419 TvecFloat Faux1, Faux2;//, Faux3, Faux4; 6420 #endif 6421 6422 int i, err, /*j,*/ b, bAux; 6423 // signed int Ivec1, Ivec2, Ivec3; 6424 // signed short *Svec1; 6425 // unsigned int *UIvec1; 6426 // unsigned short *USvec1; 6427 // unsigned char *UCvec1; 6428 #if defined TEST_FLOATS 6429 // float *Fvec1; 6430 #endif 6431 6432 /* For saturated rutines */ 6433 // long long int LLaux; 6434 6435 #if defined TEST_FLOATS 6436 // float Faux; 6437 #endif 6438 signed int Iaux, I1;//, I2; 6439 // unsigned int UIaux, UI1, UI2; 6440 // signed short Saux; 6441 // unsigned short USaux; 6442 // signed char Caux; 6443 // unsigned char UCaux; 6444 6445 /* 6446 union 6447 { 6448 float f; 6449 signed int si; 6450 unsigned int ui; 6451 signed short ss[2]; 6452 unsigned short us[2]; 6453 signed char sc[4]; 6454 unsigned char uc[4]; 6455 } INTunion1, INTunion2; 6456 6457 union 6458 { 6459 signed short ss; 6460 unsigned short us; 6461 signed char sc[2]; 6462 unsigned char uc[2]; 6463 } SHOunion1, SHOunion2; 6464 */ 6465 6466 6467 #if defined (GCC_COMPILER) 6468 vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 6469 vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 6470 vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127}; 6471 vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7}; 6472 vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; 6473 vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}; 6474 vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3}; 6475 vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000}; 6476 vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767}; 6477 vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3}; 6478 vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1}; 6479 vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4}; 6480 vector signed int Icons1 = (vector signed int){-4, -1, 1, 4}; 6481 vector signed int Icons2 = (vector signed int){1, 1, 1, 1}; 6482 vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF}; 6483 vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1}; 6484 vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1}; 6485 vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2}; 6486 6487 #if defined TEST_FLOATS 6488 vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999}; 6489 vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0}; 6490 vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0}; 6491 #endif 6492 6493 #elif defined (MAC_COMPILER) || defined(XLC_COMPILER) 6494 vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 6495 vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); 6496 vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127); 6497 vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7); 6498 vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2); 6499 vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8); 6500 vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3); 6501 vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000); 6502 vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767); 6503 vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3); 6504 vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1); 6505 vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4); 6506 vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4); 6507 vector signed int Icons2 = (vector signed int)(1, 1, 1, 1); 6508 vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF); 6509 vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1); 6510 vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1); 6511 vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2); 6512 6513 #if defined TEST_FLOATS 6514 vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999); 6515 vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0); 6516 vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0); 6517 #endif 6518 6519 #endif 6520 6521 6522 /* Function vec_all_eq */ 6523 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6524 err = 0; 6525 UCaux1.v = UCcons1; 6526 UCaux2.v = UCcons1; 6527 I1 = vec_all_eq( UCaux1.v, UCaux2.v ); 6528 Iaux = 1; 6529 for ( i=0; i< 16; i++ ) 6530 { 6531 Iaux = Iaux && (UCaux1.e[i]==UCaux2.e[i]); 6532 } 6533 if (I1 != Iaux) err++; 6534 6535 UCaux1.v = UCcons2; 6536 UCaux2.v = UCcons3; 6537 I1 = vec_all_eq( UCaux1.v, UCaux2.v ); 6538 Iaux = 1; 6539 for ( i=0; i< 16; i++ ) 6540 { 6541 Iaux = Iaux && (UCaux1.e[i]==UCaux2.e[i]); 6542 } 6543 if (I1 != Iaux) err++; 6544 6545 if (err) 6546 printf("Function vec_all_eq [type unsigned char] ===> Error\n"); 6547 else 6548 printf("Function vec_all_eq [type unsigned char] ===> OK\n"); 6549 6550 err = 0; 6551 Caux1.v = Ccons1; 6552 Caux2.v = Ccons1; 6553 I1 = vec_all_eq( Caux1.v, Caux2.v ); 6554 Iaux = 1; 6555 for ( i=0; i< 16; i++ ) 6556 { 6557 Iaux = Iaux && (Caux1.e[i]==Caux2.e[i]); 6558 } 6559 if (I1 != Iaux) err++; 6560 6561 Caux1.v = Ccons1; 6562 Caux2.v = Ccons2; 6563 I1 = vec_all_eq( Caux1.v, Caux2.v ); 6564 Iaux = 1; 6565 for ( i=0; i< 16; i++ ) 6566 { 6567 Iaux = Iaux && (Caux1.e[i]==Caux2.e[i]); 6568 } 6569 if (I1 != Iaux) err++; 6570 6571 if (err) 6572 printf("Function vec_all_eq [type char] ===> Error\n"); 6573 else 6574 printf("Function vec_all_eq [type char] ===> OK\n"); 6575 6576 err = 0; 6577 USaux1.v = UScons1; 6578 USaux2.v = UScons1; 6579 I1 = vec_all_eq( USaux1.v, USaux2.v ); 6580 Iaux = 1; 6581 for ( i=0; i< 8; i++ ) 6582 { 6583 Iaux = Iaux && (USaux1.e[i]==USaux2.e[i]); 6584 } 6585 if (I1 != Iaux) err++; 6586 6587 USaux1.v = UScons2; 6588 USaux2.v = UScons3; 6589 I1 = vec_all_eq( USaux1.v, USaux2.v ); 6590 Iaux = 1; 6591 for ( i=0; i< 8; i++ ) 6592 { 6593 Iaux = Iaux && (USaux1.e[i]==USaux2.e[i]); 6594 } 6595 if (I1 != Iaux) err++; 6596 6597 if (err) 6598 printf("Function vec_all_eq [type unsigned short] ===> Error\n"); 6599 else 6600 printf("Function vec_all_eq [type unsigned short] ===> OK\n"); 6601 6602 err = 0; 6603 Saux1.v = Scons1; 6604 Saux2.v = Scons1; 6605 I1 = vec_all_eq( Saux1.v, Saux2.v ); 6606 Iaux = 1; 6607 for ( i=0; i< 8; i++ ) 6608 { 6609 Iaux = Iaux && (Saux1.e[i]==Saux2.e[i]); 6610 } 6611 if (I1 != Iaux) err++; 6612 6613 Saux1.v = Scons2; 6614 Saux2.v = Scons3; 6615 I1 = vec_all_eq( Saux1.v, Saux2.v ); 6616 Iaux = 1; 6617 for ( i=0; i< 8; i++ ) 6618 { 6619 Iaux = Iaux && (Saux1.e[i]==Saux2.e[i]); 6620 } 6621 if (I1 != Iaux) err++; 6622 6623 if (err) 6624 printf("Function vec_all_eq [type short] ===> Error\n"); 6625 else 6626 printf("Function vec_all_eq [type short] ===> OK\n"); 6627 6628 err = 0; 6629 UIaux1.v = UIcons1; 6630 UIaux2.v = UIcons1; 6631 I1 = vec_all_eq( UIaux1.v, UIaux2.v ); 6632 Iaux = 1; 6633 for ( i=0; i< 4; i++ ) 6634 { 6635 Iaux = Iaux && (UIaux1.e[i]==UIaux2.e[i]); 6636 } 6637 if (I1 != Iaux) err++; 6638 6639 UIaux1.v = UIcons2; 6640 UIaux2.v = UIcons3; 6641 I1 = vec_all_eq( UIaux1.v, UIaux2.v ); 6642 Iaux = 1; 6643 for ( i=0; i< 4; i++ ) 6644 { 6645 Iaux = Iaux && (UIaux1.e[i]==UIaux2.e[i]); 6646 } 6647 if (I1 != Iaux) err++; 6648 6649 if (err) 6650 printf("Function vec_all_eq [type unsigned int] ===> Error\n"); 6651 else 6652 printf("Function vec_all_eq [type unsigned int] ===> OK\n"); 6653 6654 err = 0; 6655 Iaux1.v = Icons1; 6656 Iaux2.v = Icons1; 6657 I1 = vec_all_eq( Iaux1.v, Iaux2.v ); 6658 Iaux = 1; 6659 for ( i=0; i< 4; i++ ) 6660 { 6661 Iaux = Iaux && (Iaux1.e[i]==Iaux2.e[i]); 6662 } 6663 if (I1 != Iaux) err++; 6664 6665 Iaux1.v = Icons1; 6666 Iaux2.v = Icons2; 6667 I1 = vec_all_eq( Iaux1.v, Iaux2.v ); 6668 Iaux = 1; 6669 for ( i=0; i< 4; i++ ) 6670 { 6671 Iaux = Iaux && (Iaux1.e[i]==Iaux2.e[i]); 6672 } 6673 if (I1 != Iaux) err++; 6674 6675 if (err) 6676 printf("Function vec_all_eq [type int] ===> Error\n"); 6677 else 6678 printf("Function vec_all_eq [type int] ===> OK\n"); 6679 6680 #if defined TEST_FLOATS 6681 err = 0; 6682 Faux1.v = Fcons1; 6683 Faux2.v = Fcons1; 6684 I1 = vec_all_eq( Faux1.v, Faux2.v ); 6685 Iaux = 1; 6686 for ( i=0; i< 4; i++ ) 6687 { 6688 Iaux = Iaux && (Faux1.e[i]==Faux2.e[i]); 6689 } 6690 if (I1 != Iaux) err++; 6691 6692 Faux1.v = Fcons1; 6693 Faux2.v = Fcons2; 6694 I1 = vec_all_eq( Faux1.v, Faux2.v ); 6695 Iaux = 1; 6696 for ( i=0; i< 4; i++ ) 6697 { 6698 Iaux = Iaux && (Faux1.e[i]==Faux2.e[i]); 6699 } 6700 if (I1 != Iaux) err++; 6701 6702 if (err) 6703 printf("Function vec_all_eq [type float] ===> Error\n"); 6704 else 6705 printf("Function vec_all_eq [type float] ===> OK\n"); 6706 #endif 6707 6708 /* Function vec_all_ge */ 6709 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6710 err = 0; 6711 UCaux1.v = UCcons2; 6712 UCaux2.v = UCcons2; 6713 I1 = vec_all_ge( UCaux1.v, UCaux2.v ); 6714 Iaux = 1; 6715 for ( i=0; i< 16; i++ ) 6716 { 6717 Iaux = Iaux && (UCaux1.e[i]>=UCaux2.e[i]); 6718 } 6719 if (I1 != Iaux) err++; 6720 6721 UCaux1.v = UCcons2; 6722 UCaux2.v = UCcons3; 6723 I1 = vec_all_ge( UCaux1.v, UCaux2.v ); 6724 Iaux = 1; 6725 for ( i=0; i< 16; i++ ) 6726 { 6727 Iaux = Iaux && (UCaux1.e[i]>=UCaux2.e[i]); 6728 } 6729 if (I1 != Iaux) err++; 6730 6731 if (err) 6732 printf("Function vec_all_ge [type unsigned char] ===> Error\n"); 6733 else 6734 printf("Function vec_all_ge [type unsigned char] ===> OK\n"); 6735 6736 err = 0; 6737 Caux1.v = Ccons2; 6738 Caux2.v = Ccons2; 6739 I1 = vec_all_ge( Caux1.v, Caux2.v ); 6740 Iaux = 1; 6741 for ( i=0; i< 16; i++ ) 6742 { 6743 Iaux = Iaux && (Caux1.e[i]>=Caux2.e[i]); 6744 } 6745 if (I1 != Iaux) err++; 6746 6747 Caux1.v = Ccons2; 6748 Caux2.v = Ccons3; 6749 I1 = vec_all_ge( Caux1.v, Caux2.v ); 6750 Iaux = 1; 6751 for ( i=0; i< 16; i++ ) 6752 { 6753 Iaux = Iaux && (Caux1.e[i]>=Caux2.e[i]); 6754 } 6755 if (I1 != Iaux) err++; 6756 6757 if (err) 6758 printf("Function vec_all_ge [type char] ===> Error\n"); 6759 else 6760 printf("Function vec_all_ge [type char] ===> OK\n"); 6761 6762 err = 0; 6763 USaux1.v = UScons3; 6764 USaux2.v = UScons2; 6765 I1 = vec_all_ge( USaux1.v, USaux2.v ); 6766 Iaux = 1; 6767 for ( i=0; i< 8; i++ ) 6768 { 6769 Iaux = Iaux && (USaux1.e[i]>=USaux2.e[i]); 6770 } 6771 if (I1 != Iaux) err++; 6772 6773 USaux1.v = UScons1; 6774 USaux2.v = UScons2; 6775 I1 = vec_all_ge( USaux1.v, USaux2.v ); 6776 Iaux = 1; 6777 for ( i=0; i< 8; i++ ) 6778 { 6779 Iaux = Iaux && (USaux1.e[i]>=USaux2.e[i]); 6780 } 6781 if (I1 != Iaux) err++; 6782 6783 if (err) 6784 printf("Function vec_all_ge [type unsigned short] ===> Error\n"); 6785 else 6786 printf("Function vec_all_ge [type unsigned short] ===> OK\n"); 6787 6788 err = 0; 6789 Saux1.v = Scons1; 6790 Saux2.v = Scons1; 6791 I1 = vec_all_ge( Saux1.v, Saux2.v ); 6792 Iaux = 1; 6793 for ( i=0; i< 8; i++ ) 6794 { 6795 Iaux = Iaux && (Saux1.e[i]>=Saux2.e[i]); 6796 } 6797 if (I1 != Iaux) err++; 6798 6799 Saux1.v = Scons2; 6800 Saux2.v = Scons3; 6801 I1 = vec_all_ge( Saux1.v, Saux2.v ); 6802 Iaux = 1; 6803 for ( i=0; i< 8; i++ ) 6804 { 6805 Iaux = Iaux && (Saux1.e[i]>=Saux2.e[i]); 6806 } 6807 if (I1 != Iaux) err++; 6808 6809 if (err) 6810 printf("Function vec_all_ge [type short] ===> Error\n"); 6811 else 6812 printf("Function vec_all_ge [type short] ===> OK\n"); 6813 6814 err = 0; 6815 UIaux1.v = UIcons3; 6816 UIaux2.v = UIcons2; 6817 I1 = vec_all_ge( UIaux1.v, UIaux2.v ); 6818 Iaux = 1; 6819 for ( i=0; i< 4; i++ ) 6820 { 6821 Iaux = Iaux && (UIaux1.e[i]>=UIaux2.e[i]); 6822 } 6823 if (I1 != Iaux) err++; 6824 6825 UIaux1.v = UIcons1; 6826 UIaux2.v = UIcons2; 6827 I1 = vec_all_ge( UIaux1.v, UIaux2.v ); 6828 Iaux = 1; 6829 for ( i=0; i< 4; i++ ) 6830 { 6831 Iaux = Iaux && (UIaux1.e[i]>=UIaux2.e[i]); 6832 } 6833 if (I1 != Iaux) err++; 6834 6835 if (err) 6836 printf("Function vec_all_ge [type unsigned int] ===> Error\n"); 6837 else 6838 printf("Function vec_all_ge [type unsigned int] ===> OK\n"); 6839 6840 err = 0; 6841 Iaux1.v = Icons2; 6842 Iaux2.v = Icons2; 6843 I1 = vec_all_ge( Iaux1.v, Iaux2.v ); 6844 Iaux = 1; 6845 for ( i=0; i< 4; i++ ) 6846 { 6847 Iaux = Iaux && (Iaux1.e[i]>=Iaux2.e[i]); 6848 } 6849 if (I1 != Iaux) err++; 6850 6851 Iaux1.v = Icons2; 6852 Iaux2.v = Icons1; 6853 I1 = vec_all_ge( Iaux1.v, Iaux2.v ); 6854 Iaux = 1; 6855 for ( i=0; i< 4; i++ ) 6856 { 6857 Iaux = Iaux && (Iaux1.e[i]>=Iaux2.e[i]); 6858 } 6859 if (I1 != Iaux) err++; 6860 6861 if (err) 6862 printf("Function vec_all_ge [type int] ===> Error\n"); 6863 else 6864 printf("Function vec_all_ge [type int] ===> OK\n"); 6865 6866 #if defined TEST_FLOATS 6867 err = 0; 6868 Faux1.v = Fcons2; 6869 Faux2.v = Fcons1; 6870 I1 = vec_all_ge( Faux1.v, Faux2.v ); 6871 Iaux = 1; 6872 for ( i=0; i< 4; i++ ) 6873 { 6874 Iaux = Iaux && (Faux1.e[i]>=Faux2.e[i]); 6875 } 6876 if (I1 != Iaux) err++; 6877 6878 Faux1.v = Fcons2; 6879 Faux2.v = Fcons3; 6880 I1 = vec_all_ge( Faux1.v, Faux2.v ); 6881 Iaux = 1; 6882 for ( i=0; i< 4; i++ ) 6883 { 6884 Iaux = Iaux && (Faux1.e[i]>=Faux2.e[i]); 6885 } 6886 if (I1 != Iaux) err++; 6887 6888 if (err) 6889 printf("Function vec_all_ge [type float] ===> Error\n"); 6890 else 6891 printf("Function vec_all_ge [type float] ===> OK\n"); 6892 #endif 6893 6894 /* Function vec_all_gt */ 6895 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 6896 err = 0; 6897 # if defined (GCC_COMPILER) 6898 UCaux1.v = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 2, 3, 4, 5, 6, 7, 8, 9}; 6899 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 6900 UCaux1.v = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 2, 3, 4, 5, 6, 7, 8, 9); 6901 # endif 6902 UCaux2.v = UCcons2; 6903 I1 = vec_all_gt( UCaux1.v, UCaux2.v ); 6904 Iaux = 1; 6905 for ( i=0; i< 16; i++ ) 6906 { 6907 Iaux = Iaux && (UCaux1.e[i]>UCaux2.e[i]); 6908 } 6909 if (I1 != Iaux) err++; 6910 6911 UCaux1.v = UCcons2; 6912 UCaux2.v = UCcons3; 6913 I1 = vec_all_gt( UCaux1.v, UCaux2.v ); 6914 Iaux = 1; 6915 for ( i=0; i< 16; i++ ) 6916 { 6917 Iaux = Iaux && (UCaux1.e[i]>UCaux2.e[i]); 6918 } 6919 if (I1 != Iaux) err++; 6920 6921 if (err) 6922 printf("Function vec_all_gt [type unsigned char] ===> Error\n"); 6923 else 6924 printf("Function vec_all_gt [type unsigned char] ===> OK\n"); 6925 6926 err = 0; 6927 # if defined (GCC_COMPILER) 6928 Caux1.v = (vector signed char){9, 8, 7, 6, 5, 4, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 6929 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 6930 Caux1.v = (vector signed char)(9, 8, 7, 6, 5, 4, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10); 6931 # endif 6932 Caux2.v = Ccons2; 6933 I1 = vec_all_gt( Caux1.v, Caux2.v ); 6934 Iaux = 1; 6935 for ( i=0; i< 16; i++ ) 6936 { 6937 Iaux = Iaux && (Caux1.e[i]>Caux2.e[i]); 6938 } 6939 if (I1 != Iaux) err++; 6940 6941 Caux1.v = Ccons2; 6942 Caux2.v = Ccons3; 6943 I1 = vec_all_gt( Caux1.v, Caux2.v ); 6944 Iaux = 1; 6945 for ( i=0; i< 16; i++ ) 6946 { 6947 Iaux = Iaux && (Caux1.e[i]>Caux2.e[i]); 6948 } 6949 if (I1 != Iaux) err++; 6950 6951 if (err) 6952 printf("Function vec_all_gt [type char] ===> Error\n"); 6953 else 6954 printf("Function vec_all_gt [type char] ===> OK\n"); 6955 6956 err = 0; 6957 # if defined (GCC_COMPILER) 6958 USaux1.v = (vector unsigned short){65532, 65533, 65534, 65535, 2, 3, 4, 5}; 6959 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 6960 USaux1.v = (vector unsigned short)(65532, 65533, 65534, 65535, 2, 3, 4, 5); 6961 # endif 6962 USaux2.v = UScons2; 6963 I1 = vec_all_gt( USaux1.v, USaux2.v ); 6964 Iaux = 1; 6965 for ( i=0; i< 8; i++ ) 6966 { 6967 Iaux = Iaux && (USaux1.e[i]>USaux2.e[i]); 6968 } 6969 if (I1 != Iaux) err++; 6970 6971 USaux1.v = UScons1; 6972 USaux2.v = UScons2; 6973 I1 = vec_all_gt( USaux1.v, USaux2.v ); 6974 Iaux = 1; 6975 for ( i=0; i< 8; i++ ) 6976 { 6977 Iaux = Iaux && (USaux1.e[i]>USaux2.e[i]); 6978 } 6979 if (I1 != Iaux) err++; 6980 6981 if (err) 6982 printf("Function vec_all_gt [type unsigned short] ===> Error\n"); 6983 else 6984 printf("Function vec_all_gt [type unsigned short] ===> OK\n"); 6985 6986 err = 0; 6987 # if defined (GCC_COMPILER) 6988 Saux1.v = (vector signed short){4, 3, 2, 1, 2, 3, 4, 5}; 6989 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 6990 Saux1.v = (vector signed short)(4, 3, 2, 1, 2, 3, 4, 5); 6991 # endif 6992 Saux2.v = Scons1; 6993 I1 = vec_all_gt( Saux1.v, Saux2.v ); 6994 Iaux = 1; 6995 for ( i=0; i< 8; i++ ) 6996 { 6997 Iaux = Iaux && (Saux1.e[i]>Saux2.e[i]); 6998 } 6999 if (I1 != Iaux) err++; 7000 7001 Saux1.v = Scons2; 7002 Saux2.v = Scons3; 7003 I1 = vec_all_gt( Saux1.v, Saux2.v ); 7004 Iaux = 1; 7005 for ( i=0; i< 8; i++ ) 7006 { 7007 Iaux = Iaux && (Saux1.e[i]>Saux2.e[i]); 7008 } 7009 if (I1 != Iaux) err++; 7010 7011 if (err) 7012 printf("Function vec_all_gt [type short] ===> Error\n"); 7013 else 7014 printf("Function vec_all_gt [type short] ===> OK\n"); 7015 7016 err = 0; 7017 # if defined (GCC_COMPILER) 7018 UIaux1.v = (vector unsigned int){3, 2, 3, 2}; 7019 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7020 UIaux1.v = (vector unsigned int)(3, 2, 3, 2); 7021 # endif 7022 UIaux2.v = UIcons2; 7023 I1 = vec_all_gt( UIaux1.v, UIaux2.v ); 7024 Iaux = 1; 7025 for ( i=0; i< 4; i++ ) 7026 { 7027 Iaux = Iaux && (UIaux1.e[i]>UIaux2.e[i]); 7028 } 7029 if (I1 != Iaux) err++; 7030 7031 UIaux1.v = UIcons1; 7032 UIaux2.v = UIcons2; 7033 I1 = vec_all_gt( UIaux1.v, UIaux2.v ); 7034 Iaux = 1; 7035 for ( i=0; i< 4; i++ ) 7036 { 7037 Iaux = Iaux && (UIaux1.e[i]>UIaux2.e[i]); 7038 } 7039 if (I1 != Iaux) err++; 7040 7041 if (err) 7042 printf("Function vec_all_gt [type unsigned int] ===> Error\n"); 7043 else 7044 printf("Function vec_all_gt [type unsigned int] ===> OK\n"); 7045 7046 err = 0; 7047 # if defined (GCC_COMPILER) 7048 Iaux1.v = (vector signed int){4, 10, 10, 4}; 7049 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7050 Iaux1.v = (vector signed int)(4, 10, 10, 4); 7051 # endif 7052 Iaux2.v = Icons2; 7053 I1 = vec_all_gt( Iaux1.v, Iaux2.v ); 7054 Iaux = 1; 7055 for ( i=0; i< 4; i++ ) 7056 { 7057 Iaux = Iaux && (Iaux1.e[i]>Iaux2.e[i]); 7058 } 7059 if (I1 != Iaux) err++; 7060 7061 Iaux1.v = Icons2; 7062 Iaux2.v = Icons1; 7063 I1 = vec_all_gt( Iaux1.v, Iaux2.v ); 7064 Iaux = 1; 7065 for ( i=0; i< 4; i++ ) 7066 { 7067 Iaux = Iaux && (Iaux1.e[i]>Iaux2.e[i]); 7068 } 7069 if (I1 != Iaux) err++; 7070 7071 if (err) 7072 printf("Function vec_all_gt [type int] ===> Error\n"); 7073 else 7074 printf("Function vec_all_gt [type int] ===> OK\n"); 7075 7076 #if defined TEST_FLOATS 7077 err = 0; 7078 # if defined (GCC_COMPILER) 7079 Faux1.v = (vector float){100000000000.0, 12.0, 12.0, 1234567890.0}; 7080 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7081 Faux1.v = (vector float)(100000000000.0, 12.0, 12.0, 1234567890.0); 7082 # endif 7083 Faux2.v = Fcons1; 7084 I1 = vec_all_gt( Faux1.v, Faux2.v ); 7085 Iaux = 1; 7086 for ( i=0; i< 4; i++ ) 7087 { 7088 Iaux = Iaux && (Faux1.e[i]>Faux2.e[i]); 7089 } 7090 if (I1 != Iaux) err++; 7091 7092 Faux1.v = Fcons2; 7093 Faux2.v = Fcons3; 7094 I1 = vec_all_gt( Faux1.v, Faux2.v ); 7095 Iaux = 1; 7096 for ( i=0; i< 4; i++ ) 7097 { 7098 Iaux = Iaux && (Faux1.e[i]>Faux2.e[i]); 7099 } 7100 if (I1 != Iaux) err++; 7101 7102 if (err) 7103 printf("Function vec_all_gt [type float] ===> Error\n"); 7104 else 7105 printf("Function vec_all_gt [type float] ===> OK\n"); 7106 #endif 7107 7108 #if defined TEST_FLOATS 7109 /* Function vec_all_in */ 7110 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 7111 err = 0; 7112 Faux1.v = Fcons1; 7113 Faux2.v = Fcons2; 7114 I1 = vec_all_in( Faux1.v, Faux2.v ); 7115 Iaux = 1; 7116 for ( i=0; i< 4; i++ ) 7117 { 7118 Iaux = Iaux && ((Faux1.e[i]<=Faux2.e[i]) && (Faux1.e[i]>=-Faux2.e[i])); 7119 } 7120 if (I1 != Iaux) err++; 7121 7122 Faux1.v = Fcons2; 7123 # if defined (GCC_COMPILER) 7124 Faux2.v = (vector float){100000000000.0, 1.0, 1.0, 1234567890.0}; 7125 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7126 Faux2.v = (vector float)(100000000000.0, 1.0, 1.0, 1234567890.0); 7127 # endif 7128 I1 = vec_all_in( Faux1.v, Faux2.v ); 7129 Iaux = 1; 7130 for ( i=0; i< 4; i++ ) 7131 { 7132 Iaux = Iaux && ((Faux1.e[i]<=Faux2.e[i]) && (Faux1.e[i]>=-Faux2.e[i])); 7133 } 7134 if (I1 != Iaux) err++; 7135 7136 if (err) 7137 printf("Function vec_all_in [type float] ===> Error\n"); 7138 else 7139 printf("Function vec_all_in [type float] ===> OK\n"); 7140 #endif 7141 7142 /* Function vec_all_le */ 7143 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 7144 err = 0; 7145 UCaux1.v = UCcons2; 7146 UCaux2.v = UCcons3; 7147 I1 = vec_all_le( UCaux1.v, UCaux2.v ); 7148 Iaux = 1; 7149 for ( i=0; i< 16; i++ ) 7150 { 7151 Iaux = Iaux && (UCaux1.e[i]<=UCaux2.e[i]); 7152 } 7153 if (I1 != Iaux) err++; 7154 7155 UCaux1.v = UCcons1; 7156 UCaux2.v = UCcons2; 7157 I1 = vec_all_le( UCaux1.v, UCaux2.v ); 7158 Iaux = 1; 7159 for ( i=0; i< 16; i++ ) 7160 { 7161 Iaux = Iaux && (UCaux1.e[i]<=UCaux2.e[i]); 7162 } 7163 if (I1 != Iaux) err++; 7164 7165 if (err) 7166 printf("Function vec_all_le [type unsigned char] ===> Error\n"); 7167 else 7168 printf("Function vec_all_le [type unsigned char] ===> OK\n"); 7169 7170 err = 0; 7171 Caux1.v = Ccons2; 7172 Caux2.v = Ccons2; 7173 I1 = vec_all_le( Caux1.v, Caux2.v ); 7174 Iaux = 1; 7175 for ( i=0; i< 16; i++ ) 7176 { 7177 Iaux = Iaux && (Caux1.e[i]<=Caux2.e[i]); 7178 } 7179 if (I1 != Iaux) err++; 7180 7181 Caux1.v = Ccons2; 7182 Caux2.v = Ccons3; 7183 I1 = vec_all_le( Caux1.v, Caux2.v ); 7184 Iaux = 1; 7185 for ( i=0; i< 16; i++ ) 7186 { 7187 Iaux = Iaux && (Caux1.e[i]<=Caux2.e[i]); 7188 } 7189 if (I1 != Iaux) err++; 7190 7191 if (err) 7192 printf("Function vec_all_le [type char] ===> Error\n"); 7193 else 7194 printf("Function vec_all_le [type char] ===> OK\n"); 7195 7196 err = 0; 7197 USaux1.v = UScons2; 7198 USaux2.v = UScons3; 7199 I1 = vec_all_le( USaux1.v, USaux2.v ); 7200 Iaux = 1; 7201 for ( i=0; i< 8; i++ ) 7202 { 7203 Iaux = Iaux && (USaux1.e[i]<=USaux2.e[i]); 7204 } 7205 if (I1 != Iaux) err++; 7206 7207 USaux1.v = UScons1; 7208 USaux2.v = UScons2; 7209 I1 = vec_all_le( USaux1.v, USaux2.v ); 7210 Iaux = 1; 7211 for ( i=0; i< 8; i++ ) 7212 { 7213 Iaux = Iaux && (USaux1.e[i]<=USaux2.e[i]); 7214 } 7215 if (I1 != Iaux) err++; 7216 7217 if (err) 7218 printf("Function vec_all_le [type unsigned short] ===> Error\n"); 7219 else 7220 printf("Function vec_all_le [type unsigned short] ===> OK\n"); 7221 7222 err = 0; 7223 Saux1.v = Scons1; 7224 Saux2.v = Scons1; 7225 I1 = vec_all_le( Saux1.v, Saux2.v ); 7226 Iaux = 1; 7227 for ( i=0; i< 8; i++ ) 7228 { 7229 Iaux = Iaux && (Saux1.e[i]<=Saux2.e[i]); 7230 } 7231 if (I1 != Iaux) err++; 7232 7233 Saux1.v = Scons2; 7234 Saux2.v = Scons3; 7235 I1 = vec_all_le( Saux1.v, Saux2.v ); 7236 Iaux = 1; 7237 for ( i=0; i< 8; i++ ) 7238 { 7239 Iaux = Iaux && (Saux1.e[i]<=Saux2.e[i]); 7240 } 7241 if (I1 != Iaux) err++; 7242 7243 if (err) 7244 printf("Function vec_all_le [type short] ===> Error\n"); 7245 else 7246 printf("Function vec_all_le [type short] ===> OK\n"); 7247 7248 err = 0; 7249 UIaux1.v = UIcons2; 7250 UIaux2.v = UIcons3; 7251 I1 = vec_all_le( UIaux1.v, UIaux2.v ); 7252 Iaux = 1; 7253 for ( i=0; i< 4; i++ ) 7254 { 7255 Iaux = Iaux && (UIaux1.e[i]<=UIaux2.e[i]); 7256 } 7257 if (I1 != Iaux) err++; 7258 7259 UIaux1.v = UIcons1; 7260 UIaux2.v = UIcons2; 7261 I1 = vec_all_le( UIaux1.v, UIaux2.v ); 7262 Iaux = 1; 7263 for ( i=0; i< 4; i++ ) 7264 { 7265 Iaux = Iaux && (UIaux1.e[i]<=UIaux2.e[i]); 7266 } 7267 if (I1 != Iaux) err++; 7268 7269 if (err) 7270 printf("Function vec_all_le [type unsigned int] ===> Error\n"); 7271 else 7272 printf("Function vec_all_le [type unsigned int] ===> OK\n"); 7273 7274 err = 0; 7275 Iaux1.v = Icons2; 7276 Iaux2.v = Icons2; 7277 I1 = vec_all_le( Iaux1.v, Iaux2.v ); 7278 Iaux = 1; 7279 for ( i=0; i< 4; i++ ) 7280 { 7281 Iaux = Iaux && (Iaux1.e[i]<=Iaux2.e[i]); 7282 } 7283 if (I1 != Iaux) err++; 7284 7285 Iaux1.v = Icons1; 7286 Iaux2.v = Icons2; 7287 I1 = vec_all_le( Iaux1.v, Iaux2.v ); 7288 Iaux = 1; 7289 for ( i=0; i< 4; i++ ) 7290 { 7291 Iaux = Iaux && (Iaux1.e[i]<=Iaux2.e[i]); 7292 } 7293 if (I1 != Iaux) err++; 7294 7295 if (err) 7296 printf("Function vec_all_le [type int] ===> Error\n"); 7297 else 7298 printf("Function vec_all_le [type int] ===> OK\n"); 7299 7300 #if defined TEST_FLOATS 7301 err = 0; 7302 Faux1.v = Fcons1; 7303 Faux2.v = Fcons2; 7304 I1 = vec_all_le( Faux1.v, Faux2.v ); 7305 Iaux = 1; 7306 for ( i=0; i< 4; i++ ) 7307 { 7308 Iaux = Iaux && (Faux1.e[i]<=Faux2.e[i]); 7309 } 7310 if (I1 != Iaux) err++; 7311 7312 Faux1.v = Fcons2; 7313 Faux2.v = Fcons3; 7314 I1 = vec_all_le( Faux1.v, Faux2.v ); 7315 Iaux = 1; 7316 for ( i=0; i< 4; i++ ) 7317 { 7318 Iaux = Iaux && (Faux1.e[i]<=Faux2.e[i]); 7319 } 7320 if (I1 != Iaux) err++; 7321 7322 if (err) 7323 printf("Function vec_all_le [type float] ===> Error\n"); 7324 else 7325 printf("Function vec_all_le [type float] ===> OK\n"); 7326 #endif 7327 7328 /* Function vec_all_lt */ 7329 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 7330 err = 0; 7331 UCaux1.v = UCcons2; 7332 # if defined (GCC_COMPILER) 7333 UCaux2.v = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 2, 3, 4, 5, 6, 7, 8, 9}; 7334 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7335 UCaux2.v = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 2, 3, 4, 5, 6, 7, 8, 9); 7336 # endif 7337 I1 = vec_all_lt( UCaux1.v, UCaux2.v ); 7338 Iaux = 1; 7339 for ( i=0; i< 16; i++ ) 7340 { 7341 Iaux = Iaux && (UCaux1.e[i]<UCaux2.e[i]); 7342 } 7343 if (I1 != Iaux) err++; 7344 7345 UCaux1.v = UCcons3; 7346 UCaux2.v = UCcons2; 7347 I1 = vec_all_lt( UCaux1.v, UCaux2.v ); 7348 Iaux = 1; 7349 for ( i=0; i< 16; i++ ) 7350 { 7351 Iaux = Iaux && (UCaux1.e[i]<UCaux2.e[i]); 7352 } 7353 if (I1 != Iaux) err++; 7354 7355 if (err) 7356 printf("Function vec_all_lt [type unsigned char] ===> Error\n"); 7357 else 7358 printf("Function vec_all_lt [type unsigned char] ===> OK\n"); 7359 7360 err = 0; 7361 Caux1.v = Ccons2; 7362 # if defined (GCC_COMPILER) 7363 Caux2.v = (vector signed char){9, 8, 7, 6, 5, 4, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 7364 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7365 Caux2.v = (vector signed char)(9, 8, 7, 6, 5, 4, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10); 7366 # endif 7367 I1 = vec_all_lt( Caux1.v, Caux2.v ); 7368 Iaux = 1; 7369 for ( i=0; i< 16; i++ ) 7370 { 7371 Iaux = Iaux && (Caux1.e[i]<Caux2.e[i]); 7372 } 7373 if (I1 != Iaux) err++; 7374 7375 Caux1.v = Ccons3; 7376 Caux2.v = Ccons2; 7377 I1 = vec_all_lt( Caux1.v, Caux2.v ); 7378 Iaux = 1; 7379 for ( i=0; i< 16; i++ ) 7380 { 7381 Iaux = Iaux && (Caux1.e[i]<Caux2.e[i]); 7382 } 7383 if (I1 != Iaux) err++; 7384 7385 if (err) 7386 printf("Function vec_all_lt [type char] ===> Error\n"); 7387 else 7388 printf("Function vec_all_lt [type char] ===> OK\n"); 7389 7390 err = 0; 7391 USaux1.v = UScons2; 7392 # if defined (GCC_COMPILER) 7393 USaux2.v = (vector unsigned short){65532, 65533, 65534, 65535, 2, 3, 4, 5}; 7394 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7395 USaux2.v = (vector unsigned short)(65532, 65533, 65534, 65535, 2, 3, 4, 5); 7396 # endif 7397 I1 = vec_all_lt( USaux1.v, USaux2.v ); 7398 Iaux = 1; 7399 for ( i=0; i< 8; i++ ) 7400 { 7401 Iaux = Iaux && (USaux1.e[i]<USaux2.e[i]); 7402 } 7403 if (I1 != Iaux) err++; 7404 7405 USaux1.v = UScons2; 7406 USaux2.v = UScons1; 7407 I1 = vec_all_lt( USaux1.v, USaux2.v ); 7408 Iaux = 1; 7409 for ( i=0; i< 8; i++ ) 7410 { 7411 Iaux = Iaux && (USaux1.e[i]<USaux2.e[i]); 7412 } 7413 if (I1 != Iaux) err++; 7414 7415 if (err) 7416 printf("Function vec_all_lt [type unsigned short] ===> Error\n"); 7417 else 7418 printf("Function vec_all_lt [type unsigned short] ===> OK\n"); 7419 7420 err = 0; 7421 Saux1.v = Scons1; 7422 # if defined (GCC_COMPILER) 7423 Saux2.v = (vector signed short){4, 3, 2, 1, 2, 3, 4, 5}; 7424 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7425 Saux2.v = (vector signed short)(4, 3, 2, 1, 2, 3, 4, 5); 7426 # endif 7427 I1 = vec_all_lt( Saux1.v, Saux2.v ); 7428 Iaux = 1; 7429 for ( i=0; i< 8; i++ ) 7430 { 7431 Iaux = Iaux && (Saux1.e[i]<Saux2.e[i]); 7432 } 7433 if (I1 != Iaux) err++; 7434 7435 Saux1.v = Scons3; 7436 Saux2.v = Scons2; 7437 I1 = vec_all_lt( Saux1.v, Saux2.v ); 7438 Iaux = 1; 7439 for ( i=0; i< 8; i++ ) 7440 { 7441 Iaux = Iaux && (Saux1.e[i]<Saux2.e[i]); 7442 } 7443 if (I1 != Iaux) err++; 7444 7445 if (err) 7446 printf("Function vec_all_lt [type short] ===> Error\n"); 7447 else 7448 printf("Function vec_all_lt [type short] ===> OK\n"); 7449 7450 err = 0; 7451 UIaux1.v = UIcons2; 7452 # if defined (GCC_COMPILER) 7453 UIaux2.v = (vector unsigned int){3, 2, 3, 2}; 7454 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7455 UIaux2.v = (vector unsigned int)(3, 2, 3, 2); 7456 # endif 7457 I1 = vec_all_lt( UIaux1.v, UIaux2.v ); 7458 Iaux = 1; 7459 for ( i=0; i< 4; i++ ) 7460 { 7461 Iaux = Iaux && (UIaux1.e[i]<UIaux2.e[i]); 7462 } 7463 if (I1 != Iaux) err++; 7464 7465 UIaux1.v = UIcons2; 7466 UIaux2.v = UIcons1; 7467 I1 = vec_all_lt( UIaux1.v, UIaux2.v ); 7468 Iaux = 1; 7469 for ( i=0; i< 4; i++ ) 7470 { 7471 Iaux = Iaux && (UIaux1.e[i]<UIaux2.e[i]); 7472 } 7473 if (I1 != Iaux) err++; 7474 7475 if (err) 7476 printf("Function vec_all_lt [type unsigned int] ===> Error\n"); 7477 else 7478 printf("Function vec_all_lt [type unsigned int] ===> OK\n"); 7479 7480 err = 0; 7481 Iaux1.v = Icons2; 7482 # if defined (GCC_COMPILER) 7483 Iaux2.v = (vector signed int){4, 10, 10, 4}; 7484 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7485 Iaux2.v = (vector signed int)(4, 10, 10, 4); 7486 # endif 7487 I1 = vec_all_lt( Iaux1.v, Iaux2.v ); 7488 Iaux = 1; 7489 for ( i=0; i< 4; i++ ) 7490 { 7491 Iaux = Iaux && (Iaux1.e[i]<Iaux2.e[i]); 7492 } 7493 if (I1 != Iaux) err++; 7494 7495 Iaux1.v = Icons1; 7496 Iaux2.v = Icons2; 7497 I1 = vec_all_lt( Iaux1.v, Iaux2.v ); 7498 Iaux = 1; 7499 for ( i=0; i< 4; i++ ) 7500 { 7501 Iaux = Iaux && (Iaux1.e[i]<Iaux2.e[i]); 7502 } 7503 if (I1 != Iaux) err++; 7504 7505 if (err) 7506 printf("Function vec_all_lt [type int] ===> Error\n"); 7507 else 7508 printf("Function vec_all_lt [type int] ===> OK\n"); 7509 7510 #if defined TEST_FLOATS 7511 err = 0; 7512 Faux1.v = Fcons1; 7513 # if defined (GCC_COMPILER) 7514 Faux2.v = (vector float){100000000000.0, 12.0, 12.0, 1234567890.0}; 7515 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7516 Faux2.v = (vector float)(100000000000.0, 12.0, 12.0, 1234567890.0); 7517 # endif 7518 I1 = vec_all_lt( Faux1.v, Faux2.v ); 7519 Iaux = 1; 7520 for ( i=0; i< 4; i++ ) 7521 { 7522 Iaux = Iaux && (Faux1.e[i]<Faux2.e[i]); 7523 } 7524 if (I1 != Iaux) err++; 7525 7526 Faux1.v = Fcons3; 7527 Faux2.v = Fcons2; 7528 I1 = vec_all_lt( Faux1.v, Faux2.v ); 7529 Iaux = 1; 7530 for ( i=0; i< 4; i++ ) 7531 { 7532 Iaux = Iaux && (Faux1.e[i]<Faux2.e[i]); 7533 } 7534 if (I1 != Iaux) err++; 7535 7536 if (err) 7537 printf("Function vec_all_lt [type float] ===> Error\n"); 7538 else 7539 printf("Function vec_all_lt [type float] ===> OK\n"); 7540 #endif 7541 7542 #if defined TEST_FLOATS 7543 /* Function vec_all_nan */ 7544 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 7545 err = 0; 7546 # if defined (GCC_COMPILER) 7547 Faux1.v = (vector float){NAN, NAN, NAN, NAN}; 7548 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7549 Faux1.v = (vector float)(NAN, NAN, NAN, NAN); 7550 # endif 7551 I1 = vec_all_nan( Faux1.v ); 7552 Iaux = 1; 7553 for ( i=0; i< 4; i++ ) 7554 { 7555 Iaux = Iaux && (isnan(Faux1.e[i])); 7556 } 7557 if (I1 != Iaux) err++; 7558 7559 Faux1.v = Fcons1; 7560 I1 = vec_all_nan( Faux1.v ); 7561 Iaux = 1; 7562 for ( i=0; i< 4; i++ ) 7563 { 7564 Iaux = Iaux && (isnan(Faux1.e[i])); 7565 } 7566 if (I1 != Iaux) err++; 7567 7568 if (err) 7569 printf("Function vec_all_nan [type float] ===> Error\n"); 7570 else 7571 printf("Function vec_all_nan [type float] ===> OK\n"); 7572 #endif 7573 7574 /* Function vec_all_ne */ 7575 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 7576 err = 0; 7577 # if defined (GCC_COMPILER) 7578 Caux1.v = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 7579 Caux2.v = (vector signed char){-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -8}; 7580 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7581 Caux1.v = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 7582 Caux2.v = (vector signed char)(-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -8); 7583 # endif 7584 b = vec_all_ne (Caux1.v, Caux2.v); 7585 bAux = 1; 7586 for (i=0; i<16; i++) 7587 bAux = bAux && (Caux1.e[i]!=Caux2.e[i]); 7588 if (bAux != b) err = 1; 7589 7590 # if defined (GCC_COMPILER) 7591 Caux1.v = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 7592 Caux2.v = (vector signed char){-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 4, 6, 7, -8}; 7593 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7594 Caux1.v = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 7595 Caux2.v = (vector signed char)(-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 4, 6, 7, -8); 7596 # endif 7597 b = vec_all_ne (Caux1.v, Caux2.v); 7598 bAux= 1; 7599 for (i=0; i<16; i++) 7600 bAux= bAux && (Caux1.e[i]!=Caux2.e[i]); 7601 if (bAux!=b) err= 1; 7602 7603 # if defined (GCC_COMPILER) 7604 Caux1.v = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 7605 Caux2.v = (vector signed char){-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 4, 6, 7, -8}; 7606 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7607 Caux1.v = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 7608 Caux2.v = (vector signed char)(-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 4, 6, 7, -8); 7609 # endif 7610 b = vec_all_ne (Caux1.v, Caux2.v); 7611 bAux = 1; 7612 for (i=0; i<16; i++) 7613 bAux = bAux && (Caux1.e[i] != Caux2.e[i]); 7614 if (bAux != b) err = 1; 7615 7616 if (err) 7617 printf("Function vec_all_ne [type char] ===> Error\n"); 7618 else 7619 printf("Function vec_all_ne [type char] ===> OK\n"); 7620 7621 7622 err = 0; 7623 # if defined (GCC_COMPILER) 7624 UCaux1.v = (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 7625 UCaux2.v = (vector unsigned char){201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200}; 7626 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7627 UCaux1.v = (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 7628 UCaux2.v = (vector unsigned char)(201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200); 7629 # endif 7630 7631 b = vec_all_ne (UCaux1.v, UCaux2.v); 7632 bAux= 1; 7633 for (i=0; i<16; i++) 7634 bAux= bAux && (UCaux1.e[i]!=UCaux2.e[i]); 7635 if (bAux!=b) err= 1; 7636 7637 # if defined (GCC_COMPILER) 7638 UCaux1.v = (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 7639 UCaux2.v = (vector unsigned char){201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200}; 7640 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7641 UCaux1.v = (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 7642 UCaux2.v = (vector unsigned char)(201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200); 7643 # endif 7644 b = vec_all_ne (UCaux1.v, UCaux2.v); 7645 bAux = 1; 7646 for (i=0; i<16; i++) 7647 bAux = bAux && (UCaux1.e[i] != UCaux2.e[i]); 7648 if (bAux != b) err = 1; 7649 7650 # if defined (GCC_COMPILER) 7651 UCaux1.v = (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 7652 UCaux2.v = (vector unsigned char){201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200}; 7653 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7654 UCaux1.v = (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 7655 UCaux2.v = (vector unsigned char)(201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200); 7656 # endif 7657 b = vec_all_ne (UCaux1.v, UCaux2.v); 7658 bAux = 1; 7659 for (i=0; i<16; i++) 7660 bAux = bAux && (UCaux1.e[i] != UCaux2.e[i]); 7661 if (bAux != b) err = 1; 7662 7663 if (err) 7664 printf("Function vec_all_ne [type unsigned char] ===> Error\n"); 7665 else 7666 printf("Function vec_all_ne [type unsigned char] ===> OK\n"); 7667 7668 7669 err = 0; 7670 # if defined (GCC_COMPILER) 7671 Saux1.v = (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 7672 Saux2.v = (vector signed short){-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800}; 7673 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7674 Saux1.v = (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 7675 Saux2.v = (vector signed short)(-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800); 7676 # endif 7677 b = vec_all_ne (Saux1.v, Saux2.v); 7678 bAux = 1; 7679 for (i=0; i<8; i++) 7680 bAux = bAux && (Saux1.e[i] != Saux2.e[i]); 7681 if (bAux != b) err = 1; 7682 7683 # if defined (GCC_COMPILER) 7684 Saux1.v = (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 7685 Saux2.v = (vector signed short){-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800}; 7686 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7687 Saux1.v = (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 7688 Saux2.v = (vector signed short)(-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800); 7689 # endif 7690 b = vec_all_ne (Saux1.v, Saux2.v); 7691 bAux = 1; 7692 for (i=0; i<8; i++) 7693 bAux = bAux && (Saux1.e[i] != Saux2.e[i]); 7694 if (bAux != b) err = 1; 7695 7696 # if defined (GCC_COMPILER) 7697 Saux1.v = (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 7698 Saux2.v = (vector signed short){-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800}; 7699 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7700 Saux1.v = (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 7701 Saux2.v = (vector signed short)(-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800); 7702 # endif 7703 b = vec_all_ne (Saux1.v, Saux2.v); 7704 bAux = 1; 7705 for (i=0; i<8; i++) 7706 bAux = bAux && (Saux1.e[i] != Saux2.e[i]); 7707 if (bAux != b) err = 1; 7708 7709 if (err) 7710 printf("Function vec_all_ne [type short] ===> Error\n"); 7711 else 7712 printf("Function vec_all_ne [type short] ===> OK\n"); 7713 7714 7715 err = 0; 7716 # if defined (GCC_COMPILER) 7717 USaux1.v = (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 7718 USaux2.v = (vector unsigned short){47000, 46000, 45000, 0, 3300, 3200, 3100,48000}; 7719 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7720 USaux1.v = (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 7721 USaux2.v = (vector unsigned short)(47000, 46000, 45000, 0, 3300, 3200, 3100,48000); 7722 # endif 7723 b = vec_all_ne (USaux1.v, USaux2.v); 7724 bAux = 1; 7725 for (i=0; i<8; i++) 7726 bAux = bAux && (USaux1.e[i] != USaux2.e[i]); 7727 if (bAux != b) err = 1; 7728 7729 # if defined (GCC_COMPILER) 7730 USaux1.v = (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 7731 USaux2.v = (vector unsigned short){47000, 46000, 45000, 0, 3300, 3200, 3100,48000}; 7732 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7733 USaux1.v = (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 7734 USaux2.v = (vector unsigned short)(47000, 46000, 45000, 0, 3300, 3200, 3100,48000); 7735 # endif 7736 b = vec_all_ne (USaux1.v, USaux2.v); 7737 bAux = 1; 7738 for (i=0; i<8; i++) 7739 bAux = bAux && (USaux1.e[i] != USaux2.e[i]); 7740 if (bAux != b) err = 1; 7741 7742 # if defined (GCC_COMPILER) 7743 USaux1.v = (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 7744 USaux2.v = (vector unsigned short){47000, 46000, 45000, 0, 3300, 3200, 3100,48000}; 7745 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7746 USaux1.v = (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 7747 USaux2.v = (vector unsigned short)(47000, 46000, 45000, 0, 3300, 3200, 3100,48000); 7748 # endif 7749 b = vec_all_ne (USaux1.v, USaux2.v); 7750 bAux = 1; 7751 for (i=0; i<8; i++) 7752 bAux = bAux && (USaux1.e[i] != USaux2.e[i]); 7753 if (bAux != b) err = 1; 7754 7755 if (err) 7756 printf("Function vec_all_ne [type unsigned short] ===> Error\n"); 7757 else 7758 printf("Function vec_all_ne [type unsigned short] ===> OK\n"); 7759 7760 7761 err = 0; 7762 # if defined (GCC_COMPILER) 7763 Iaux1.v = (vector signed int){-1003800, -1003700, 0, 1003300}; 7764 Iaux2.v = (vector signed int){-1003700, 0, 1003300,-1003800}; 7765 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7766 Iaux1.v = (vector signed int)(-1003800, -1003700, 0, 1003300); 7767 Iaux2.v = (vector signed int)(-1003700, 0, 1003300,-1003800); 7768 # endif 7769 b = vec_all_ne (Iaux1.v, Iaux2.v); 7770 bAux = 1; 7771 for (i=0; i<4; i++) 7772 bAux = bAux && (Iaux1.e[i] != Iaux2.e[i]); 7773 if (bAux != b) err = 1; 7774 7775 # if defined (GCC_COMPILER) 7776 Iaux1.v = (vector signed int){-1003800, -1003700, 0, 1003300}; 7777 Iaux2.v = (vector signed int){-1003700, 0, 1003300,-1003800}; 7778 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7779 Iaux1.v = (vector signed int)(-1003800, -1003700, 0, 1003300); 7780 Iaux2.v = (vector signed int)(-1003700, 0, 1003300,-1003800); 7781 # endif 7782 b = vec_all_ne (Iaux1.v, Iaux2.v); 7783 bAux = 1; 7784 for (i=0; i<4; i++) 7785 bAux = bAux && (Iaux1.e[i] != Iaux2.e[i]); 7786 if (bAux != b) err = 1; 7787 7788 # if defined (GCC_COMPILER) 7789 Iaux1.v= (vector signed int){-1003800, -1003700, 0, 1003300}; 7790 Iaux2.v= (vector signed int){-1003700, 0, 1003300,-1003800}; 7791 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7792 Iaux1.v= (vector signed int)(-1003800, -1003700, 0, 1003300); 7793 Iaux2.v= (vector signed int)(-1003700, 0, 1003300,-1003800); 7794 # endif 7795 b = vec_all_ne (Iaux1.v, Iaux2.v); 7796 bAux = 1; 7797 for (i=0; i<4; i++) 7798 bAux = bAux && (Iaux1.e[i] != Iaux2.e[i]); 7799 if (bAux != b) err = 1; 7800 7801 if (err) 7802 printf("Function vec_all_ne [type int] ===> Error\n"); 7803 else 7804 printf("Function vec_all_ne [type int] ===> OK\n"); 7805 7806 7807 err = 0; 7808 # if defined (GCC_COMPILER) 7809 UIaux1.v = (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 7810 UIaux2.v = (vector unsigned int){ 12345678, 0, 1,0xFFFFF000}; 7811 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7812 UIaux1.v = (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 7813 UIaux2.v = (vector unsigned int)( 12345678, 0, 1,0xFFFFF000); 7814 # endif 7815 b = vec_all_ne (UIaux1.v, UIaux2.v); 7816 bAux = 1; 7817 for (i=0; i<4; i++) 7818 bAux = bAux && (UIaux1.e[i] != UIaux2.e[i]); 7819 if (bAux != b) err = 1; 7820 7821 # if defined (GCC_COMPILER) 7822 UIaux1.v = (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 7823 UIaux2.v = (vector unsigned int){ 12345678, 0, 1,0xFFFFF000}; 7824 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7825 UIaux1.v = (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 7826 UIaux2.v = (vector unsigned int)( 12345678, 0, 1,0xFFFFF000); 7827 # endif 7828 b = vec_all_ne (UIaux1.v, UIaux2.v); 7829 bAux = 1; 7830 for (i=0; i<4; i++) 7831 bAux = bAux && (UIaux1.e[i] != UIaux2.e[i]); 7832 if (bAux != b) err = 1; 7833 7834 # if defined (GCC_COMPILER) 7835 UIaux1.v = (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 7836 UIaux2.v = (vector unsigned int){ 12345678, 0, 1,0xFFFFF000}; 7837 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7838 UIaux1.v = (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 7839 UIaux2.v = (vector unsigned int)( 12345678, 0, 1,0xFFFFF000); 7840 # endif 7841 b = vec_all_ne (UIaux1.v, UIaux2.v); 7842 bAux = 1; 7843 for (i=0; i<4; i++) 7844 bAux = bAux && (UIaux1.e[i] != UIaux2.e[i]); 7845 if (bAux != b) err = 1; 7846 7847 if (err) 7848 printf("Function vec_all_ne [type unsigned int] ===> Error\n"); 7849 else 7850 printf("Function vec_all_ne [type unsigned int] ===> OK\n"); 7851 7852 #if defined TEST_FLOATS 7853 err = 0; 7854 # if defined (GCC_COMPILER) 7855 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7856 Faux2.v = (vector float) { 1.0, 0.5, -3.999, -1.5}; 7857 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7858 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7859 Faux2.v = (vector float) ( 1.0, 0.5, -3.999, -1.5); 7860 # endif 7861 b = vec_all_ne (Faux1.v, Faux2.v); 7862 bAux = 1; 7863 for (i=0; i<4; i++) 7864 bAux = bAux && (Faux1.e[i] != Faux2.e[i]); 7865 if (bAux != b) err = 1; 7866 7867 # if defined (GCC_COMPILER) 7868 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7869 Faux2.v = (vector float) { 1.0, 0.5, -3.999, -1.5}; 7870 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7871 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7872 Faux2.v = (vector float) ( 1.0, 0.5, -3.999, -1.5); 7873 # endif 7874 b = vec_all_ne (Faux1.v, Faux2.v); 7875 bAux = 1; 7876 for (i=0; i<4; i++) 7877 bAux = bAux && (Faux1.e[i] != Faux2.e[i]); 7878 if (bAux != b) err = 1; 7879 7880 # if defined (GCC_COMPILER) 7881 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7882 Faux2.v = (vector float) { 1.0, 0.5, -3.999, -1.5}; 7883 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7884 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7885 Faux2.v = (vector float) ( 1.0, 0.5, -3.999, -1.5); 7886 # endif 7887 b = vec_all_ne (Faux1.v, Faux2.v); 7888 bAux = 1; 7889 for (i=0; i<4; i++) 7890 bAux = bAux && (Faux1.e[i] != Faux2.e[i]); 7891 if (bAux != b) err = 1; 7892 7893 if (err) 7894 printf("Function vec_all_ne [type float] ===> Error\n"); 7895 else 7896 printf("Function vec_all_ne [type float] ===> OK\n"); 7897 #endif 7898 7899 #if defined TEST_FLOATS 7900 /* Function vec_all_nge */ 7901 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 7902 err = 0; 7903 # if defined (GCC_COMPILER) 7904 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7905 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 7906 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7907 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7908 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 7909 # endif 7910 b = vec_all_nge (Faux1.v, Faux2.v); 7911 bAux = 1; 7912 for (i=0; i<4; i++) 7913 bAux = bAux && (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 7914 (Faux1.e[i] < Faux2.e[i])); 7915 if (bAux != b) err = 1; 7916 7917 # if defined (GCC_COMPILER) 7918 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7919 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 7920 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7921 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7922 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 7923 # endif 7924 b = vec_all_nge (Faux1.v, Faux2.v); 7925 bAux = 1; 7926 for (i=0; i<4; i++) 7927 bAux = bAux && (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 7928 (Faux1.e[i] < Faux2.e[i])); 7929 if (bAux != b) err = 1; 7930 7931 # if defined (GCC_COMPILER) 7932 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7933 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 7934 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7935 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7936 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 7937 # endif 7938 b = vec_all_nge (Faux1.v, Faux2.v); 7939 bAux = 1; 7940 for (i=0; i<4; i++) 7941 bAux = bAux && (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 7942 (Faux1.e[i] < Faux2.e[i])); 7943 if (bAux != b) err = 1; 7944 7945 # if defined (GCC_COMPILER) 7946 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7947 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 7948 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7949 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7950 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 7951 # endif 7952 b = vec_all_nge (Faux1.v, Faux2.v); 7953 bAux = 1; 7954 for (i=0; i<4; i++) 7955 bAux = bAux && (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 7956 (Faux1.e[i] < Faux2.e[i])); 7957 if (bAux != b) err = 1; 7958 7959 if (err) 7960 printf("Function vec_all_nge [type float] ===> Error\n"); 7961 else 7962 printf("Function vec_all_nge [type float] ===> OK\n"); 7963 #endif 7964 7965 #if defined TEST_FLOATS 7966 /* Function vec_all_ngt */ 7967 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 7968 err = 0; 7969 # if defined (GCC_COMPILER) 7970 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7971 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 7972 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7973 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7974 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 7975 # endif 7976 b = vec_all_ngt (Faux1.v, Faux2.v); 7977 bAux = 1; 7978 for (i=0; i<4; i++) 7979 bAux = bAux && 7980 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] > Faux2.e[i])); 7981 if (bAux != b) err = 1; 7982 7983 # if defined (GCC_COMPILER) 7984 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7985 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 7986 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 7987 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 7988 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 7989 # endif 7990 b = vec_all_ngt (Faux1.v, Faux2.v); 7991 bAux = 1; 7992 for (i=0; i<4; i++) 7993 bAux = bAux && 7994 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] > Faux2.e[i])); 7995 if (bAux != b) err = 1; 7996 7997 # if defined (GCC_COMPILER) 7998 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 7999 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8000 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8001 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 8002 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8003 # endif 8004 b = vec_all_ngt (Faux1.v, Faux2.v); 8005 bAux = 1; 8006 for (i=0; i<4; i++) 8007 bAux = bAux && 8008 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] > Faux2.e[i])); 8009 if (bAux!=b) err= 1; 8010 8011 # if defined (GCC_COMPILER) 8012 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 8013 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8014 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8015 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 8016 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8017 # endif 8018 b = vec_all_ngt (Faux1.v, Faux2.v); 8019 bAux = 1; 8020 for (i=0; i<4; i++) 8021 bAux = bAux && 8022 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] > Faux2.e[i])); 8023 if (bAux != b) err = 1; 8024 8025 if (err) 8026 printf("Function vec_all_ngt [type float] ===> Error\n"); 8027 else 8028 printf("Function vec_all_ngt [type float] ===> OK\n"); 8029 #endif 8030 8031 #if defined TEST_FLOATS 8032 /* Function vec_all_nle */ 8033 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 8034 err = 0; 8035 # if defined (GCC_COMPILER) 8036 Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8037 Faux2.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 8038 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8039 Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8040 Faux2.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 8041 # endif 8042 b = vec_all_nle (Faux1.v, Faux2.v); 8043 bAux = 1; 8044 for (i=0; i<4; i++) 8045 bAux = bAux && 8046 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] <= Faux2.e[i])); 8047 if (bAux != b) err = 1; 8048 8049 # if defined (GCC_COMPILER) 8050 Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8051 Faux2.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 8052 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8053 Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8054 Faux2.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 8055 # endif 8056 b = vec_all_nle (Faux1.v, Faux2.v); 8057 bAux = 1; 8058 for (i=0; i<4; i++) 8059 bAux = bAux && 8060 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] <= Faux2.e[i])); 8061 if (bAux != b) err = 1; 8062 8063 # if defined (GCC_COMPILER) 8064 Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8065 Faux2.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 8066 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8067 Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8068 Faux2.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 8069 # endif 8070 b = vec_all_nle (Faux1.v, Faux2.v); 8071 bAux = 1; 8072 for (i=0; i<4; i++) 8073 bAux = bAux && 8074 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] <=Faux2.e[i])); 8075 if (bAux != b) err = 1; 8076 8077 # if defined (GCC_COMPILER) 8078 Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8079 Faux2.v = (vector float) {-1.5, 1.0, NAN, -3.999}; 8080 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8081 Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8082 Faux2.v = (vector float) (-1.5, 1.0, NAN, -3.999); 8083 # endif 8084 b = vec_all_nle (Faux1.v, Faux2.v); 8085 bAux = 1; 8086 for (i=0; i<4; i++) 8087 bAux = bAux && 8088 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] <= Faux2.e[i])); 8089 if (bAux != b) err = 1; 8090 8091 if (err) 8092 printf("Function vec_all_nle [type float] ===> Error\n"); 8093 else 8094 printf("Function vec_all_nle [type float] ===> OK\n"); 8095 #endif 8096 8097 8098 #if defined TEST_FLOATS 8099 /* Function vec_all_nlt */ 8100 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 8101 err = 0; 8102 # if defined (GCC_COMPILER) 8103 Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8104 Faux2.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 8105 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8106 Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8107 Faux2.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 8108 # endif 8109 b = vec_all_nlt (Faux1.v, Faux2.v); 8110 bAux = 1; 8111 for (i=0; i<4; i++) 8112 bAux = bAux && 8113 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] < Faux2.e[i])); 8114 if (bAux != b) err = 1; 8115 8116 # if defined (GCC_COMPILER) 8117 Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8118 Faux2.v = (vector float) {-1.5, 5.0, 0.5, -3.999}; 8119 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8120 Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8121 Faux2.v = (vector float) (-1.5, 5.0, 0.5, -3.999); 8122 # endif 8123 b = vec_all_nlt (Faux1.v, Faux2.v); 8124 bAux = 1; 8125 for (i=0; i<4; i++) 8126 bAux = bAux && 8127 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] < Faux2.e[i])); 8128 if (bAux != b) err = 1; 8129 8130 # if defined (GCC_COMPILER) 8131 Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8132 Faux2.v = (vector float) {-1.5, 1.0, 0.55, -3.999}; 8133 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8134 Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8135 Faux2.v = (vector float) (-1.5, 1.0, 0.55, -3.999); 8136 # endif 8137 b = vec_all_nlt (Faux1.v, Faux2.v); 8138 bAux = 1; 8139 for (i=0; i<4; i++) 8140 bAux = bAux && 8141 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] < Faux2.e[i])); 8142 if (bAux != b) err = 1; 8143 8144 # if defined (GCC_COMPILER) 8145 Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8146 Faux2.v = (vector float) {-1.5, 1.0, NAN, -3.999}; 8147 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8148 Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8149 Faux2.v = (vector float) (-1.5, 1.0, NAN, -3.999); 8150 # endif 8151 b = vec_all_nlt (Faux1.v, Faux2.v); 8152 bAux = 1; 8153 for (i=0; i<4; i++) 8154 bAux = bAux && 8155 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] < Faux2.e[i])); 8156 if (bAux != b) err = 1; 8157 8158 if (err) 8159 printf("Function vec_all_nlt [type float] ===> Error\n"); 8160 else 8161 printf("Function vec_all_nlt [type float] ===> OK\n"); 8162 #endif 8163 8164 8165 #if defined TEST_FLOATS 8166 /* Function vec_all_numeric */ 8167 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 8168 err = 0; 8169 # if defined (GCC_COMPILER) 8170 Faux1.v = (vector float) {0.0, 3.5, 0.55, -1.5}; 8171 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8172 Faux1.v = (vector float) (0.0, 3.5, 0.55, -1.5); 8173 # endif 8174 b = vec_all_numeric (Faux1.v); 8175 bAux = 1; 8176 for (i=0; i<4; i++) 8177 bAux = bAux && !isnan(Faux1.e[i]); 8178 if (bAux != b) err = 1; 8179 8180 # if defined (GCC_COMPILER) 8181 Faux1.v = (vector float) {0.0, 3.5, 0.5, -1.5}; 8182 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8183 Faux1.v = (vector float) (0.0, 3.5, 0.5, -1.5); 8184 # endif 8185 b = vec_all_numeric (Faux1.v); 8186 bAux = 1; 8187 for (i=0; i<4; i++) 8188 bAux = bAux && !isnan(Faux1.e[i]); 8189 if (bAux != b) err = 1; 8190 8191 # if defined (GCC_COMPILER) 8192 Faux1.v = (vector float) {0.0, 3.5, NAN, -1.5}; 8193 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8194 Faux1.v = (vector float) (0.0, 3.5, NAN, -1.5); 8195 # endif 8196 b = vec_all_numeric (Faux1.v); 8197 bAux = 1; 8198 for (i=0; i<4; i++) 8199 bAux = bAux && !isnan(Faux1.e[i]); 8200 if (bAux != b) err = 1; 8201 8202 # if defined (GCC_COMPILER) 8203 Faux1.v = (vector float) {NAN, NAN, NAN, NAN}; 8204 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8205 Faux1.v = (vector float) (NAN, NAN, NAN, NAN); 8206 # endif 8207 b = vec_all_numeric (Faux1.v); 8208 bAux = 1; 8209 for (i=0; i<4; i++) 8210 bAux = bAux && !isnan(Faux1.e[i]); 8211 if (bAux != b) err = 1; 8212 8213 if (err) 8214 printf("Function vec_all_numeric [type float] ===> Error\n"); 8215 else 8216 printf("Function vec_all_numeric [type float] ===> OK\n"); 8217 #endif 8218 8219 /* Function vec_any_eq */ 8220 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 8221 err = 0; 8222 Caux1.v= Ccons1; 8223 Caux2.v= Ccons3; 8224 b= vec_any_eq (Caux1.v, Caux2.v); 8225 bAux= 0; 8226 for (i=0; i<16; i++) 8227 bAux= bAux || (Caux1.e[i]==Caux2.e[i]); 8228 if (bAux!=b) err= 1; 8229 8230 Caux1.v= Ccons1; 8231 Caux2.v= Ccons2; 8232 b= vec_any_eq (Caux1.v, Caux2.v); 8233 bAux= 0; 8234 for (i=0; i<16; i++) 8235 bAux= bAux || (Caux1.e[i]==Caux2.e[i]); 8236 if (bAux!=b) err= 1; 8237 8238 if (err) 8239 printf("Function vec_any_eq [type char] ===> Error\n"); 8240 else 8241 printf("Function vec_any_eq [type char] ===> OK\n"); 8242 8243 8244 err = 0; 8245 UCaux1.v= UCcons1; 8246 UCaux2.v= UCcons3; 8247 b= vec_any_eq (UCaux1.v, UCaux2.v); 8248 bAux= 0; 8249 for (i=0; i<16; i++) 8250 bAux= bAux || (UCaux1.e[i]==UCaux2.e[i]); 8251 if (bAux!=b) err= 1; 8252 8253 UCaux1.v= UCcons1; 8254 UCaux2.v= UCcons2; 8255 b= vec_any_eq (UCaux1.v, UCaux2.v); 8256 bAux= 0; 8257 for (i=0; i<16; i++) 8258 bAux= bAux || (UCaux1.e[i]==UCaux2.e[i]); 8259 if (bAux!=b) err= 1; 8260 8261 if (err) 8262 printf("Function vec_any_eq [type unsigned char] ===> Error\n"); 8263 else 8264 printf("Function vec_any_eq [type unsigned char] ===> OK\n"); 8265 8266 8267 err = 0; 8268 Saux1.v= Scons1; 8269 Saux2.v= Scons3; 8270 b= vec_any_eq (Saux1.v, Saux2.v); 8271 bAux= 0; 8272 for (i=0; i<8; i++) 8273 bAux= bAux || (Saux1.e[i]==Saux2.e[i]); 8274 if (bAux!=b) err= 1; 8275 8276 Saux1.v= Scons1; 8277 Saux2.v= Scons2; 8278 b= vec_any_eq (Saux1.v, Saux2.v); 8279 bAux= 0; 8280 for (i=0; i<8; i++) 8281 bAux= bAux || (Saux1.e[i]==Saux2.e[i]); 8282 if (bAux!=b) err= 1; 8283 8284 if (err) 8285 printf("Function vec_any_eq [type short] ===> Error\n"); 8286 else 8287 printf("Function vec_any_eq [type short] ===> OK\n"); 8288 8289 8290 err = 0; 8291 USaux1.v= UScons1; 8292 USaux2.v= UScons3; 8293 b= vec_any_eq (USaux1.v, USaux2.v); 8294 bAux= 0; 8295 for (i=0; i<8; i++) 8296 bAux= bAux || (USaux1.e[i]==USaux2.e[i]); 8297 if (bAux!=b) err= 1; 8298 8299 USaux1.v= UScons1; 8300 USaux2.v= UScons2; 8301 b= vec_any_eq (USaux1.v, USaux2.v); 8302 bAux= 0; 8303 for (i=0; i<8; i++) 8304 bAux= bAux || (USaux1.e[i]==USaux2.e[i]); 8305 if (bAux!=b) err= 1; 8306 8307 if (err) 8308 printf("Function vec_any_eq [type unsigned short] ===> Error\n"); 8309 else 8310 printf("Function vec_any_eq [type unsigned short] ===> OK\n"); 8311 8312 8313 err = 0; 8314 Iaux1.v= Icons1; 8315 Iaux2.v= Icons3; 8316 b= vec_any_eq (Iaux1.v, Iaux2.v); 8317 bAux= 0; 8318 for (i=0; i<4; i++) 8319 bAux= bAux || (Iaux1.e[i]==Iaux2.e[i]); 8320 if (bAux!=b) err= 1; 8321 8322 Iaux1.v= Icons1; 8323 Iaux2.v= Icons2; 8324 b= vec_any_eq (Iaux1.v, Iaux2.v); 8325 bAux= 0; 8326 for (i=0; i<4; i++) 8327 bAux= bAux || (Iaux1.e[i]==Iaux2.e[i]); 8328 if (bAux!=b) err= 1; 8329 8330 if (err) 8331 printf("Function vec_any_eq [type int] ===> Error\n"); 8332 else 8333 printf("Function vec_any_eq [type int] ===> OK\n"); 8334 8335 8336 err = 0; 8337 UIaux1.v= UIcons1; 8338 UIaux2.v= UIcons3; 8339 b= vec_any_eq (UIaux1.v, UIaux2.v); 8340 bAux= 0; 8341 for (i=0; i<4; i++) 8342 bAux= bAux || (UIaux1.e[i]==UIaux2.e[i]); 8343 if (bAux!=b) err= 1; 8344 8345 UIaux1.v= UIcons1; 8346 UIaux2.v= UIcons2; 8347 b= vec_any_eq (UIaux1.v, UIaux2.v); 8348 bAux= 0; 8349 for (i=0; i<4; i++) 8350 bAux= bAux || (UIaux1.e[i]==UIaux2.e[i]); 8351 if (bAux!=b) err= 1; 8352 8353 if (err) 8354 printf("Function vec_any_eq [type unsigned int] ===> Error\n"); 8355 else 8356 printf("Function vec_any_eq [type unsigned int] ===> OK\n"); 8357 8358 8359 #if defined TEST_FLOATS 8360 err = 0; 8361 # if defined (GCC_COMPILER) 8362 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 8363 Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5}; 8364 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8365 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 8366 Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5); 8367 # endif 8368 b = vec_any_eq (Faux1.v, Faux2.v); 8369 bAux = 0; 8370 for (i=0; i<4; i++) 8371 bAux = bAux || (Faux1.e[i] == Faux2.e[i]); 8372 if (bAux != b) err = 1; 8373 8374 # if defined (GCC_COMPILER) 8375 Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999}; 8376 Faux2.v = (vector float) { 0.0, 3.5, 0.5, -1.5}; 8377 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8378 Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999); 8379 Faux2.v = (vector float) ( 0.0, 3.5, 0.5, -1.5); 8380 # endif 8381 b= vec_any_eq (Faux1.v, Faux2.v); 8382 bAux= 0; 8383 for (i=0; i<4; i++) 8384 bAux= bAux || (Faux1.e[i]==Faux2.e[i]); 8385 if (bAux!=b) err= 1; 8386 8387 if (err) 8388 printf("Function vec_any_eq [type float] ===> Error\n"); 8389 else 8390 printf("Function vec_any_eq [type float] ===> OK\n"); 8391 #endif 8392 8393 /* Function vec_any_ge */ 8394 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 8395 err = 0; 8396 # if defined (GCC_COMPILER) 8397 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 8398 Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 8399 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8400 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 8401 Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 8402 # endif 8403 b= vec_any_ge (Caux1.v, Caux2.v); 8404 bAux= 0; 8405 for (i=0; i<16; i++) 8406 bAux= bAux || (Caux1.e[i]>=Caux2.e[i]); 8407 if (bAux!=b) err= 1; 8408 8409 # if defined (GCC_COMPILER) 8410 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 8411 Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 8412 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8413 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 8414 Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 8415 # endif 8416 b= vec_any_ge (Caux1.v, Caux2.v); 8417 bAux= 0; 8418 for (i=0; i<16; i++) 8419 bAux= bAux || (Caux1.e[i]>=Caux2.e[i]); 8420 if (bAux!=b) err= 1; 8421 8422 # if defined (GCC_COMPILER) 8423 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 8424 Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 8425 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8426 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 8427 Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 8428 # endif 8429 b= vec_any_ge (Caux1.v, Caux2.v); 8430 bAux= 0; 8431 for (i=0; i<16; i++) 8432 bAux= bAux || (Caux1.e[i]>=Caux2.e[i]); 8433 if (bAux!=b) err= 1; 8434 8435 if (err) 8436 printf("Function vec_any_ge [type char] ===> Error\n"); 8437 else 8438 printf("Function vec_any_ge [type char] ===> OK\n"); 8439 8440 8441 err = 0; 8442 # if defined (GCC_COMPILER) 8443 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 8444 UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 8445 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8446 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 8447 UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 8448 # endif 8449 b= vec_any_ge (UCaux1.v, UCaux2.v); 8450 bAux= 0; 8451 for (i=0; i<16; i++) 8452 bAux= bAux || (UCaux1.e[i]>=UCaux2.e[i]); 8453 if (bAux!=b) err= 1; 8454 8455 # if defined (GCC_COMPILER) 8456 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 8457 UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 8458 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8459 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 8460 UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 8461 # endif 8462 b= vec_any_ge (UCaux1.v, UCaux2.v); 8463 bAux= 0; 8464 for (i=0; i<16; i++) 8465 bAux= bAux || (UCaux1.e[i]>=UCaux2.e[i]); 8466 if (bAux!=b) err= 1; 8467 8468 # if defined (GCC_COMPILER) 8469 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 8470 UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 8471 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8472 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 8473 UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 8474 # endif 8475 b= vec_any_ge (UCaux1.v, UCaux2.v); 8476 bAux= 0; 8477 for (i=0; i<16; i++) 8478 bAux= bAux || (UCaux1.e[i]>=UCaux2.e[i]); 8479 if (bAux!=b) err= 1; 8480 8481 if (err) 8482 printf("Function vec_any_ge [type unsigned char] ===> Error\n"); 8483 else 8484 printf("Function vec_any_ge [type unsigned char] ===> OK\n"); 8485 8486 8487 err = 0; 8488 # if defined (GCC_COMPILER) 8489 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 8490 Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 8491 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8492 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 8493 Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 8494 # endif 8495 b= vec_any_ge (Saux1.v, Saux2.v); 8496 bAux= 0; 8497 for (i=0; i<8; i++) 8498 bAux= bAux || (Saux1.e[i]>=Saux2.e[i]); 8499 if (bAux!=b) err= 1; 8500 8501 # if defined (GCC_COMPILER) 8502 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 8503 Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 8504 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8505 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 8506 Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 8507 # endif 8508 b= vec_any_ge (Saux1.v, Saux2.v); 8509 bAux= 0; 8510 for (i=0; i<8; i++) 8511 bAux= bAux || (Saux1.e[i]>=Saux2.e[i]); 8512 if (bAux!=b) err= 1; 8513 8514 # if defined (GCC_COMPILER) 8515 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 8516 Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 8517 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8518 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 8519 Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 8520 # endif 8521 b= vec_any_ge (Saux1.v, Saux2.v); 8522 bAux= 0; 8523 for (i=0; i<8; i++) 8524 bAux= bAux || (Saux1.e[i]>=Saux2.e[i]); 8525 if (bAux!=b) err= 1; 8526 8527 if (err) 8528 printf("Function vec_any_ge [type short] ===> Error\n"); 8529 else 8530 printf("Function vec_any_ge [type short] ===> OK\n"); 8531 8532 8533 err = 0; 8534 # if defined (GCC_COMPILER) 8535 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 8536 USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 8537 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8538 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 8539 USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 8540 # endif 8541 b= vec_any_ge (USaux1.v, USaux2.v); 8542 bAux= 0; 8543 for (i=0; i<8; i++) 8544 bAux= bAux || (USaux1.e[i]>=USaux2.e[i]); 8545 if (bAux!=b) err= 1; 8546 8547 # if defined (GCC_COMPILER) 8548 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 8549 USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 8550 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8551 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 8552 USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 8553 # endif 8554 b= vec_any_ge (USaux1.v, USaux2.v); 8555 bAux= 0; 8556 for (i=0; i<8; i++) 8557 bAux= bAux || (USaux1.e[i]>=USaux2.e[i]); 8558 if (bAux!=b) err= 1; 8559 8560 # if defined (GCC_COMPILER) 8561 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 8562 USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 8563 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8564 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 8565 USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 8566 # endif 8567 b= vec_any_ge (USaux1.v, USaux2.v); 8568 bAux= 0; 8569 for (i=0; i<8; i++) 8570 bAux= bAux || (USaux1.e[i]>=USaux2.e[i]); 8571 if (bAux!=b) err= 1; 8572 8573 if (err) 8574 printf("Function vec_any_ge [type unsigned short] ===> Error\n"); 8575 else 8576 printf("Function vec_any_ge [type unsigned short] ===> OK\n"); 8577 8578 8579 err = 0; 8580 # if defined (GCC_COMPILER) 8581 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 8582 Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 8583 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8584 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 8585 Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 8586 # endif 8587 b= vec_any_ge (Iaux1.v, Iaux2.v); 8588 bAux= 0; 8589 for (i=0; i<4; i++) 8590 bAux= bAux || (Iaux1.e[i]>=Iaux2.e[i]); 8591 if (bAux!=b) err= 1; 8592 8593 # if defined (GCC_COMPILER) 8594 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 8595 Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 8596 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8597 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 8598 Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 8599 # endif 8600 b= vec_any_ge (Iaux1.v, Iaux2.v); 8601 bAux= 0; 8602 for (i=0; i<4; i++) 8603 bAux= bAux || (Iaux1.e[i]>=Iaux2.e[i]); 8604 if (bAux!=b) err= 1; 8605 8606 # if defined (GCC_COMPILER) 8607 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 8608 Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 8609 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8610 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 8611 Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 8612 # endif 8613 b= vec_any_ge (Iaux1.v, Iaux2.v); 8614 bAux= 0; 8615 for (i=0; i<4; i++) 8616 bAux= bAux || (Iaux1.e[i]>=Iaux2.e[i]); 8617 if (bAux!=b) err= 1; 8618 8619 if (err) 8620 printf("Function vec_any_ge [type int] ===> Error\n"); 8621 else 8622 printf("Function vec_any_ge [type int] ===> OK\n"); 8623 8624 8625 err = 0; 8626 # if defined (GCC_COMPILER) 8627 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 8628 UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 8629 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8630 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 8631 UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 8632 # endif 8633 b= vec_any_ge (UIaux1.v, UIaux2.v); 8634 bAux= 0; 8635 for (i=0; i<4; i++) 8636 bAux= bAux || (UIaux1.e[i]>=UIaux2.e[i]); 8637 if (bAux!=b) err= 1; 8638 8639 # if defined (GCC_COMPILER) 8640 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 8641 UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 8642 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8643 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 8644 UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 8645 # endif 8646 b= vec_any_ge (UIaux1.v, UIaux2.v); 8647 bAux= 0; 8648 for (i=0; i<4; i++) 8649 bAux= bAux || (UIaux1.e[i]>=UIaux2.e[i]); 8650 if (bAux!=b) err= 1; 8651 8652 # if defined (GCC_COMPILER) 8653 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 8654 UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 8655 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8656 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 8657 UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 8658 # endif 8659 b= vec_any_ge (UIaux1.v, UIaux2.v); 8660 bAux= 0; 8661 for (i=0; i<4; i++) 8662 bAux= bAux || (UIaux1.e[i]>=UIaux2.e[i]); 8663 if (bAux!=b) err= 1; 8664 8665 if (err) 8666 printf("Function vec_any_ge [type unsigned int] ===> Error\n"); 8667 else 8668 printf("Function vec_any_ge [type unsigned int] ===> OK\n"); 8669 8670 #if defined TEST_FLOATS 8671 err = 0; 8672 # if defined (GCC_COMPILER) 8673 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 8674 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 8675 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8676 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 8677 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 8678 # endif 8679 b= vec_any_ge (Faux1.v, Faux2.v); 8680 bAux= 0; 8681 for (i=0; i<4; i++) 8682 bAux= bAux || (Faux1.e[i]>=Faux2.e[i]); 8683 if (bAux!=b) err= 1; 8684 8685 # if defined (GCC_COMPILER) 8686 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 8687 Faux2.v= (vector float) { 0.0, 3.5, 0.5, -1.5}; 8688 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8689 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 8690 Faux2.v= (vector float) ( 0.0, 3.5, 0.5, -1.5); 8691 # endif 8692 b= vec_any_ge (Faux1.v, Faux2.v); 8693 bAux= 0; 8694 for (i=0; i<4; i++) 8695 bAux= bAux || (Faux1.e[i]>=Faux2.e[i]); 8696 if (bAux!=b) err= 1; 8697 8698 # if defined (GCC_COMPILER) 8699 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 8700 Faux2.v= (vector float) { 0.0, 3.5,-0.5, -1.5}; 8701 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8702 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 8703 Faux2.v= (vector float) ( 0.0, 3.5,-0.5, -1.5); 8704 # endif 8705 b= vec_any_ge (Faux1.v, Faux2.v); 8706 bAux= 0; 8707 for (i=0; i<4; i++) 8708 bAux= bAux || (Faux1.e[i]>=Faux2.e[i]); 8709 if (bAux!=b) err= 1; 8710 8711 if (err) 8712 printf("Function vec_any_ge [type float] ===> Error\n"); 8713 else 8714 printf("Function vec_any_ge [type float] ===> OK\n"); 8715 #endif 8716 8717 /* Function vec_any_gt */ 8718 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 8719 err = 0; 8720 # if defined (GCC_COMPILER) 8721 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 8722 Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 8723 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8724 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 8725 Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 8726 # endif 8727 b= vec_any_gt (Caux1.v, Caux2.v); 8728 bAux= 0; 8729 for (i=0; i<16; i++) 8730 bAux= bAux || (Caux1.e[i]>Caux2.e[i]); 8731 if (bAux!=b) err= 1; 8732 8733 # if defined (GCC_COMPILER) 8734 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 8735 Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 8736 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8737 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 8738 Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 8739 # endif 8740 b= vec_any_gt (Caux1.v, Caux2.v); 8741 bAux= 0; 8742 for (i=0; i<16; i++) 8743 bAux= bAux || (Caux1.e[i]>Caux2.e[i]); 8744 if (bAux!=b) err= 1; 8745 8746 # if defined (GCC_COMPILER) 8747 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 8748 Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 8749 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8750 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 8751 Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 8752 # endif 8753 b= vec_any_gt (Caux1.v, Caux2.v); 8754 bAux= 0; 8755 for (i=0; i<16; i++) 8756 bAux= bAux || (Caux1.e[i]>Caux2.e[i]); 8757 if (bAux!=b) err= 1; 8758 8759 if (err) 8760 printf("Function vec_any_gt [type char] ===> Error\n"); 8761 else 8762 printf("Function vec_any_gt [type char] ===> OK\n"); 8763 8764 8765 err = 0; 8766 # if defined (GCC_COMPILER) 8767 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 8768 UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 8769 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8770 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 8771 UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 8772 # endif 8773 b= vec_any_gt (UCaux1.v, UCaux2.v); 8774 bAux= 0; 8775 for (i=0; i<16; i++) 8776 bAux= bAux || (UCaux1.e[i]>UCaux2.e[i]); 8777 if (bAux!=b) err= 1; 8778 8779 # if defined (GCC_COMPILER) 8780 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 8781 UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 8782 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8783 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 8784 UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 8785 # endif 8786 b= vec_any_gt (UCaux1.v, UCaux2.v); 8787 bAux= 0; 8788 for (i=0; i<16; i++) 8789 bAux= bAux || (UCaux1.e[i]>UCaux2.e[i]); 8790 if (bAux!=b) err= 1; 8791 8792 # if defined (GCC_COMPILER) 8793 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 8794 UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 8795 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8796 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 8797 UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 8798 # endif 8799 b= vec_any_gt (UCaux1.v, UCaux2.v); 8800 bAux= 0; 8801 for (i=0; i<16; i++) 8802 bAux= bAux || (UCaux1.e[i]>UCaux2.e[i]); 8803 if (bAux!=b) err= 1; 8804 8805 if (err) 8806 printf("Function vec_any_gt [type unsigned char] ===> Error\n"); 8807 else 8808 printf("Function vec_any_gt [type unsigned char] ===> OK\n"); 8809 8810 8811 err = 0; 8812 # if defined (GCC_COMPILER) 8813 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 8814 Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 8815 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8816 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 8817 Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 8818 # endif 8819 b= vec_any_gt (Saux1.v, Saux2.v); 8820 bAux= 0; 8821 for (i=0; i<8; i++) 8822 bAux= bAux || (Saux1.e[i]>Saux2.e[i]); 8823 if (bAux!=b) err= 1; 8824 8825 # if defined (GCC_COMPILER) 8826 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 8827 Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 8828 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8829 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 8830 Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 8831 # endif 8832 b= vec_any_gt (Saux1.v, Saux2.v); 8833 bAux= 0; 8834 for (i=0; i<8; i++) 8835 bAux= bAux || (Saux1.e[i]>Saux2.e[i]); 8836 if (bAux!=b) err= 1; 8837 8838 # if defined (GCC_COMPILER) 8839 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 8840 Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 8841 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8842 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 8843 Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 8844 # endif 8845 b= vec_any_gt (Saux1.v, Saux2.v); 8846 bAux= 0; 8847 for (i=0; i<8; i++) 8848 bAux= bAux || (Saux1.e[i]>Saux2.e[i]); 8849 if (bAux!=b) err= 1; 8850 8851 if (err) 8852 printf("Function vec_any_gt [type short] ===> Error\n"); 8853 else 8854 printf("Function vec_any_gt [type short] ===> OK\n"); 8855 8856 8857 err = 0; 8858 # if defined (GCC_COMPILER) 8859 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 8860 USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 8861 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8862 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 8863 USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 8864 # endif 8865 b= vec_any_gt (USaux1.v, USaux2.v); 8866 bAux= 0; 8867 for (i=0; i<8; i++) 8868 bAux= bAux || (USaux1.e[i]>USaux2.e[i]); 8869 if (bAux!=b) err= 1; 8870 8871 # if defined (GCC_COMPILER) 8872 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 8873 USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 8874 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8875 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 8876 USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 8877 # endif 8878 b= vec_any_gt (USaux1.v, USaux2.v); 8879 bAux= 0; 8880 for (i=0; i<8; i++) 8881 bAux= bAux || (USaux1.e[i]>USaux2.e[i]); 8882 if (bAux!=b) err= 1; 8883 8884 # if defined (GCC_COMPILER) 8885 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 8886 USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 8887 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8888 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 8889 USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 8890 # endif 8891 b= vec_any_gt (USaux1.v, USaux2.v); 8892 bAux= 0; 8893 for (i=0; i<8; i++) 8894 bAux= bAux || (USaux1.e[i]>USaux2.e[i]); 8895 if (bAux!=b) err= 1; 8896 8897 if (err) 8898 printf("Function vec_any_gt [type unsigned short] ===> Error\n"); 8899 else 8900 printf("Function vec_any_gt [type unsigned short] ===> OK\n"); 8901 8902 8903 err = 0; 8904 # if defined (GCC_COMPILER) 8905 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 8906 Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 8907 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8908 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 8909 Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 8910 # endif 8911 b= vec_any_gt (Iaux1.v, Iaux2.v); 8912 bAux= 0; 8913 for (i=0; i<4; i++) 8914 bAux= bAux || (Iaux1.e[i]>Iaux2.e[i]); 8915 if (bAux!=b) err= 1; 8916 8917 # if defined (GCC_COMPILER) 8918 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 8919 Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 8920 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8921 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 8922 Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 8923 # endif 8924 b= vec_any_gt (Iaux1.v, Iaux2.v); 8925 bAux= 0; 8926 for (i=0; i<4; i++) 8927 bAux= bAux || (Iaux1.e[i]>Iaux2.e[i]); 8928 if (bAux!=b) err= 1; 8929 8930 # if defined (GCC_COMPILER) 8931 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 8932 Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 8933 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8934 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 8935 Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 8936 # endif 8937 b= vec_any_gt (Iaux1.v, Iaux2.v); 8938 bAux= 0; 8939 for (i=0; i<4; i++) 8940 bAux= bAux || (Iaux1.e[i]>Iaux2.e[i]); 8941 if (bAux!=b) err= 1; 8942 8943 if (err) 8944 printf("Function vec_any_gt [type int] ===> Error\n"); 8945 else 8946 printf("Function vec_any_gt [type int] ===> OK\n"); 8947 8948 8949 err = 0; 8950 # if defined (GCC_COMPILER) 8951 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 8952 UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 8953 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8954 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 8955 UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 8956 # endif 8957 b= vec_any_gt (UIaux1.v, UIaux2.v); 8958 bAux= 0; 8959 for (i=0; i<4; i++) 8960 bAux= bAux || (UIaux1.e[i]>UIaux2.e[i]); 8961 if (bAux!=b) err= 1; 8962 8963 # if defined (GCC_COMPILER) 8964 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 8965 UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 8966 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8967 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 8968 UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 8969 # endif 8970 b= vec_any_gt (UIaux1.v, UIaux2.v); 8971 bAux= 0; 8972 for (i=0; i<4; i++) 8973 bAux= bAux || (UIaux1.e[i]>UIaux2.e[i]); 8974 if (bAux!=b) err= 1; 8975 8976 # if defined (GCC_COMPILER) 8977 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 8978 UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 8979 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 8980 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 8981 UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 8982 # endif 8983 b= vec_any_gt (UIaux1.v, UIaux2.v); 8984 bAux= 0; 8985 for (i=0; i<4; i++) 8986 bAux= bAux || (UIaux1.e[i]>UIaux2.e[i]); 8987 if (bAux!=b) err= 1; 8988 8989 if (err) 8990 printf("Function vec_any_gt [type unsigned int] ===> Error\n"); 8991 else 8992 printf("Function vec_any_gt [type unsigned int] ===> OK\n"); 8993 8994 #if defined TEST_FLOATS 8995 err = 0; 8996 # if defined (GCC_COMPILER) 8997 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 8998 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 8999 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9000 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9001 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 9002 # endif 9003 b= vec_any_gt (Faux1.v, Faux2.v); 9004 bAux= 0; 9005 for (i=0; i<4; i++) 9006 bAux= bAux || (Faux1.e[i]>Faux2.e[i]); 9007 if (bAux!=b) err= 1; 9008 9009 # if defined (GCC_COMPILER) 9010 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 9011 Faux2.v= (vector float) { 0.0, 3.5, 0.5, -1.5}; 9012 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9013 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9014 Faux2.v= (vector float) ( 0.0, 3.5, 0.5, -1.5); 9015 # endif 9016 b= vec_any_gt (Faux1.v, Faux2.v); 9017 bAux= 0; 9018 for (i=0; i<4; i++) 9019 bAux= bAux || (Faux1.e[i]>Faux2.e[i]); 9020 if (bAux!=b) err= 1; 9021 9022 # if defined (GCC_COMPILER) 9023 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 9024 Faux2.v= (vector float) { 0.0, 3.5,-0.5, -1.5}; 9025 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9026 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9027 Faux2.v= (vector float) ( 0.0, 3.5,-0.5, -1.5); 9028 # endif 9029 b= vec_any_gt (Faux1.v, Faux2.v); 9030 bAux= 0; 9031 for (i=0; i<4; i++) 9032 bAux= bAux || (Faux1.e[i]>Faux2.e[i]); 9033 if (bAux!=b) err= 1; 9034 9035 if (err) 9036 printf("Function vec_any_gt [type float] ===> Error\n"); 9037 else 9038 printf("Function vec_any_gt [type float] ===> OK\n"); 9039 #endif 9040 9041 9042 /* Function vec_any_le */ 9043 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 9044 err = 0; 9045 # if defined (GCC_COMPILER) 9046 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9047 Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 9048 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9049 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9050 Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 9051 # endif 9052 b= vec_any_le (Caux1.v, Caux2.v); 9053 bAux= 0; 9054 for (i=0; i<16; i++) 9055 bAux= bAux || (Caux1.e[i]<=Caux2.e[i]); 9056 if (bAux!=b) err= 1; 9057 9058 # if defined (GCC_COMPILER) 9059 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9060 Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 9061 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9062 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9063 Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 9064 # endif 9065 b= vec_any_le (Caux1.v, Caux2.v); 9066 bAux= 0; 9067 for (i=0; i<16; i++) 9068 bAux= bAux || (Caux1.e[i]<=Caux2.e[i]); 9069 if (bAux!=b) err= 1; 9070 9071 # if defined (GCC_COMPILER) 9072 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9073 Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 9074 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9075 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9076 Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 9077 # endif 9078 b= vec_any_le (Caux1.v, Caux2.v); 9079 bAux= 0; 9080 for (i=0; i<16; i++) 9081 bAux= bAux || (Caux1.e[i]<=Caux2.e[i]); 9082 if (bAux!=b) err= 1; 9083 9084 if (err) 9085 printf("Function vec_any_le [type char] ===> Error\n"); 9086 else 9087 printf("Function vec_any_le [type char] ===> OK\n"); 9088 9089 9090 err = 0; 9091 # if defined (GCC_COMPILER) 9092 UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9093 UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 9094 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9095 UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9096 UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 9097 # endif 9098 b= vec_any_le (UCaux1.v, UCaux2.v); 9099 bAux= 0; 9100 for (i=0; i<16; i++) 9101 bAux= bAux || (UCaux1.e[i]<=UCaux2.e[i]); 9102 if (bAux!=b) err= 1; 9103 9104 # if defined (GCC_COMPILER) 9105 UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9106 UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 9107 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9108 UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9109 UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 9110 # endif 9111 b= vec_any_le (UCaux1.v, UCaux2.v); 9112 bAux= 0; 9113 for (i=0; i<16; i++) 9114 bAux= bAux || (UCaux1.e[i]<=UCaux2.e[i]); 9115 if (bAux!=b) err= 1; 9116 9117 # if defined (GCC_COMPILER) 9118 UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9119 UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 9120 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9121 UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9122 UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 9123 # endif 9124 b= vec_any_le (UCaux1.v, UCaux2.v); 9125 bAux= 0; 9126 for (i=0; i<16; i++) 9127 bAux= bAux || (UCaux1.e[i]<=UCaux2.e[i]); 9128 if (bAux!=b) err= 1; 9129 9130 if (err) 9131 printf("Function vec_any_le [type unsigned char] ===> Error\n"); 9132 else 9133 printf("Function vec_any_le [type unsigned char] ===> OK\n"); 9134 9135 9136 err = 0; 9137 # if defined (GCC_COMPILER) 9138 Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9139 Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 9140 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9141 Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9142 Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 9143 # endif 9144 b= vec_any_le (Saux1.v, Saux2.v); 9145 bAux= 0; 9146 for (i=0; i<8; i++) 9147 bAux= bAux || (Saux1.e[i]<=Saux2.e[i]); 9148 if (bAux!=b) err= 1; 9149 9150 # if defined (GCC_COMPILER) 9151 Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9152 Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 9153 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9154 Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9155 Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 9156 # endif 9157 b= vec_any_le (Saux1.v, Saux2.v); 9158 bAux= 0; 9159 for (i=0; i<8; i++) 9160 bAux= bAux || (Saux1.e[i]<=Saux2.e[i]); 9161 if (bAux!=b) err= 1; 9162 9163 # if defined (GCC_COMPILER) 9164 Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9165 Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 9166 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9167 Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9168 Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 9169 # endif 9170 b= vec_any_le (Saux1.v, Saux2.v); 9171 bAux= 0; 9172 for (i=0; i<8; i++) 9173 bAux= bAux || (Saux1.e[i]<=Saux2.e[i]); 9174 if (bAux!=b) err= 1; 9175 9176 if (err) 9177 printf("Function vec_any_le [type short] ===> Error\n"); 9178 else 9179 printf("Function vec_any_le [type short] ===> OK\n"); 9180 9181 9182 err = 0; 9183 # if defined (GCC_COMPILER) 9184 USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9185 USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 9186 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9187 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9188 USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 9189 # endif 9190 b= vec_any_le (USaux1.v, USaux2.v); 9191 bAux= 0; 9192 for (i=0; i<8; i++) 9193 bAux= bAux || (USaux1.e[i]<=USaux2.e[i]); 9194 if (bAux!=b) err= 1; 9195 9196 # if defined (GCC_COMPILER) 9197 USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9198 USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 9199 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9200 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9201 USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 9202 # endif 9203 b= vec_any_le (USaux1.v, USaux2.v); 9204 bAux= 0; 9205 for (i=0; i<8; i++) 9206 bAux= bAux || (USaux1.e[i]<=USaux2.e[i]); 9207 if (bAux!=b) err= 1; 9208 9209 # if defined (GCC_COMPILER) 9210 USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9211 USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 9212 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9213 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9214 USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 9215 # endif 9216 b= vec_any_le (USaux1.v, USaux2.v); 9217 bAux= 0; 9218 for (i=0; i<8; i++) 9219 bAux= bAux || (USaux1.e[i]<=USaux2.e[i]); 9220 if (bAux!=b) err= 1; 9221 9222 if (err) 9223 printf("Function vec_any_le [type unsigned short] ===> Error\n"); 9224 else 9225 printf("Function vec_any_le [type unsigned short] ===> OK\n"); 9226 9227 9228 err = 0; 9229 # if defined (GCC_COMPILER) 9230 Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9231 Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 9232 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9233 Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9234 Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 9235 # endif 9236 b= vec_any_le (Iaux1.v, Iaux2.v); 9237 bAux= 0; 9238 for (i=0; i<4; i++) 9239 bAux= bAux || (Iaux1.e[i]<=Iaux2.e[i]); 9240 if (bAux!=b) err= 1; 9241 9242 # if defined (GCC_COMPILER) 9243 Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9244 Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 9245 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9246 Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9247 Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 9248 # endif 9249 b= vec_any_le (Iaux1.v, Iaux2.v); 9250 bAux= 0; 9251 for (i=0; i<4; i++) 9252 bAux= bAux || (Iaux1.e[i]<=Iaux2.e[i]); 9253 if (bAux!=b) err= 1; 9254 9255 # if defined (GCC_COMPILER) 9256 Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9257 Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 9258 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9259 Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9260 Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 9261 # endif 9262 b= vec_any_le (Iaux1.v, Iaux2.v); 9263 bAux= 0; 9264 for (i=0; i<4; i++) 9265 bAux= bAux || (Iaux1.e[i]<=Iaux2.e[i]); 9266 if (bAux!=b) err= 1; 9267 9268 if (err) 9269 printf("Function vec_any_le [type int] ===> Error\n"); 9270 else 9271 printf("Function vec_any_le [type int] ===> OK\n"); 9272 9273 9274 err = 0; 9275 # if defined (GCC_COMPILER) 9276 UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9277 UIaux1.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 9278 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9279 UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9280 UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 9281 # endif 9282 b= vec_any_le (UIaux1.v, UIaux2.v); 9283 bAux= 0; 9284 for (i=0; i<4; i++) 9285 bAux= bAux || (UIaux1.e[i]<=UIaux2.e[i]); 9286 if (bAux!=b) err= 1; 9287 9288 # if defined (GCC_COMPILER) 9289 UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9290 UIaux1.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 9291 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9292 UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9293 UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 9294 # endif 9295 b= vec_any_le (UIaux1.v, UIaux2.v); 9296 bAux= 0; 9297 for (i=0; i<4; i++) 9298 bAux= bAux || (UIaux1.e[i]<=UIaux2.e[i]); 9299 if (bAux!=b) err= 1; 9300 9301 # if defined (GCC_COMPILER) 9302 UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9303 UIaux1.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 9304 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9305 UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9306 UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 9307 # endif 9308 b= vec_any_le (UIaux1.v, UIaux2.v); 9309 bAux= 0; 9310 for (i=0; i<4; i++) 9311 bAux= bAux || (UIaux1.e[i]<=UIaux2.e[i]); 9312 if (bAux!=b) err= 1; 9313 9314 if (err) 9315 printf("Function vec_any_le [type unsigned int] ===> Error\n"); 9316 else 9317 printf("Function vec_any_le [type unsigned int] ===> OK\n"); 9318 9319 #if defined TEST_FLOATS 9320 err = 0; 9321 # if defined (GCC_COMPILER) 9322 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 9323 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 9324 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9325 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9326 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 9327 # endif 9328 b= vec_any_le (Faux1.v, Faux2.v); 9329 bAux= 0; 9330 for (i=0; i<4; i++) 9331 bAux= bAux || (Faux1.e[i]<=Faux2.e[i]); 9332 if (bAux!=b) err= 1; 9333 9334 # if defined (GCC_COMPILER) 9335 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 9336 Faux1.v= (vector float) { 0.0, 3.5, 0.5, -1.5}; 9337 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9338 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9339 Faux1.v= (vector float) ( 0.0, 3.5, 0.5, -1.5); 9340 # endif 9341 b= vec_any_le (Faux1.v, Faux2.v); 9342 bAux= 0; 9343 for (i=0; i<4; i++) 9344 bAux= bAux || (Faux1.e[i]<=Faux2.e[i]); 9345 if (bAux!=b) err= 1; 9346 9347 # if defined (GCC_COMPILER) 9348 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 9349 Faux1.v= (vector float) { 0.0, 3.5,-0.5, -1.5}; 9350 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9351 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9352 Faux1.v= (vector float) ( 0.0, 3.5,-0.5, -1.5); 9353 # endif 9354 b= vec_any_le (Faux1.v, Faux2.v); 9355 bAux= 0; 9356 for (i=0; i<4; i++) 9357 bAux= bAux || (Faux1.e[i]<=Faux2.e[i]); 9358 if (bAux!=b) err= 1; 9359 9360 if (err) 9361 printf("Function vec_any_le [type float] ===> Error\n"); 9362 else 9363 printf("Function vec_any_le [type float] ===> OK\n"); 9364 #endif 9365 9366 9367 /* Function vec_any_lt */ 9368 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 9369 err = 0; 9370 # if defined (GCC_COMPILER) 9371 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9372 Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 9373 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9374 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9375 Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 9376 # endif 9377 b= vec_any_lt (Caux1.v, Caux2.v); 9378 bAux= 0; 9379 for (i=0; i<16; i++) 9380 bAux= bAux || (Caux1.e[i]<Caux2.e[i]); 9381 if (bAux!=b) err= 1; 9382 9383 # if defined (GCC_COMPILER) 9384 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9385 Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 9386 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9387 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9388 Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 9389 # endif 9390 b= vec_any_lt (Caux1.v, Caux2.v); 9391 bAux= 0; 9392 for (i=0; i<16; i++) 9393 bAux= bAux || (Caux1.e[i]<Caux2.e[i]); 9394 if (bAux!=b) err= 1; 9395 9396 # if defined (GCC_COMPILER) 9397 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9398 Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 9399 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9400 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9401 Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9); 9402 # endif 9403 b= vec_any_lt (Caux1.v, Caux2.v); 9404 bAux= 0; 9405 for (i=0; i<16; i++) 9406 bAux= bAux || (Caux1.e[i]<Caux2.e[i]); 9407 if (bAux!=b) err= 1; 9408 9409 if (err) 9410 printf("Function vec_any_lt [type char] ===> Error\n"); 9411 else 9412 printf("Function vec_any_lt [type char] ===> OK\n"); 9413 9414 9415 err = 0; 9416 # if defined (GCC_COMPILER) 9417 UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9418 UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 9419 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9420 UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9421 UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 9422 # endif 9423 b= vec_any_lt (UCaux1.v, UCaux2.v); 9424 bAux= 0; 9425 for (i=0; i<16; i++) 9426 bAux= bAux || (UCaux1.e[i]<UCaux2.e[i]); 9427 if (bAux!=b) err= 1; 9428 9429 # if defined (GCC_COMPILER) 9430 UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9431 UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 9432 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9433 UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9434 UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 9435 # endif 9436 b= vec_any_lt (UCaux1.v, UCaux2.v); 9437 bAux= 0; 9438 for (i=0; i<16; i++) 9439 bAux= bAux || (UCaux1.e[i]<UCaux2.e[i]); 9440 if (bAux!=b) err= 1; 9441 9442 # if defined (GCC_COMPILER) 9443 UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9444 UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; 9445 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9446 UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9447 UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250); 9448 # endif 9449 b= vec_any_lt (UCaux1.v, UCaux2.v); 9450 bAux= 0; 9451 for (i=0; i<16; i++) 9452 bAux= bAux || (UCaux1.e[i]<UCaux2.e[i]); 9453 if (bAux!=b) err= 1; 9454 9455 if (err) 9456 printf("Function vec_any_lt [type unsigned char] ===> Error\n"); 9457 else 9458 printf("Function vec_any_lt [type unsigned char] ===> OK\n"); 9459 9460 9461 err = 0; 9462 # if defined (GCC_COMPILER) 9463 Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9464 Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 9465 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9466 Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9467 Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 9468 # endif 9469 b= vec_any_lt (Saux1.v, Saux2.v); 9470 bAux= 0; 9471 for (i=0; i<8; i++) 9472 bAux= bAux || (Saux1.e[i]<Saux2.e[i]); 9473 if (bAux!=b) err= 1; 9474 9475 # if defined (GCC_COMPILER) 9476 Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9477 Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 9478 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9479 Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9480 Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 9481 # endif 9482 b= vec_any_lt (Saux1.v, Saux2.v); 9483 bAux= 0; 9484 for (i=0; i<8; i++) 9485 bAux= bAux || (Saux1.e[i]<Saux2.e[i]); 9486 if (bAux!=b) err= 1; 9487 9488 # if defined (GCC_COMPILER) 9489 Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9490 Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000}; 9491 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9492 Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9493 Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000); 9494 # endif 9495 b= vec_any_lt (Saux1.v, Saux2.v); 9496 bAux= 0; 9497 for (i=0; i<8; i++) 9498 bAux= bAux || (Saux1.e[i]<Saux2.e[i]); 9499 if (bAux!=b) err= 1; 9500 9501 if (err) 9502 printf("Function vec_any_lt [type short] ===> Error\n"); 9503 else 9504 printf("Function vec_any_lt [type short] ===> OK\n"); 9505 9506 9507 err = 0; 9508 # if defined (GCC_COMPILER) 9509 USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9510 USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 9511 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9512 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9513 USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 9514 # endif 9515 b= vec_any_lt (USaux1.v, USaux2.v); 9516 bAux= 0; 9517 for (i=0; i<8; i++) 9518 bAux= bAux || (USaux1.e[i]<USaux2.e[i]); 9519 if (bAux!=b) err= 1; 9520 9521 # if defined (GCC_COMPILER) 9522 USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9523 USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 9524 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9525 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9526 USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 9527 # endif 9528 b= vec_any_lt (USaux1.v, USaux2.v); 9529 bAux= 0; 9530 for (i=0; i<8; i++) 9531 bAux= bAux || (USaux1.e[i]<USaux2.e[i]); 9532 if (bAux!=b) err= 1; 9533 9534 # if defined (GCC_COMPILER) 9535 USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9536 USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000}; 9537 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9538 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9539 USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000); 9540 # endif 9541 b= vec_any_lt (USaux1.v, USaux2.v); 9542 bAux= 0; 9543 for (i=0; i<8; i++) 9544 bAux= bAux || (USaux1.e[i]<USaux2.e[i]); 9545 if (bAux!=b) err= 1; 9546 9547 if (err) 9548 printf("Function vec_any_lt [type unsigned short] ===> Error\n"); 9549 else 9550 printf("Function vec_any_lt [type unsigned short] ===> OK\n"); 9551 9552 9553 err = 0; 9554 # if defined (GCC_COMPILER) 9555 Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9556 Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 9557 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9558 Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9559 Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 9560 # endif 9561 b= vec_any_lt (Iaux1.v, Iaux2.v); 9562 bAux= 0; 9563 for (i=0; i<4; i++) 9564 bAux= bAux || (Iaux1.e[i]<Iaux2.e[i]); 9565 if (bAux!=b) err= 1; 9566 9567 # if defined (GCC_COMPILER) 9568 Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9569 Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 9570 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9571 Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9572 Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 9573 # endif 9574 b= vec_any_lt (Iaux1.v, Iaux2.v); 9575 bAux= 0; 9576 for (i=0; i<4; i++) 9577 bAux= bAux || (Iaux1.e[i]<Iaux2.e[i]); 9578 if (bAux!=b) err= 1; 9579 9580 # if defined (GCC_COMPILER) 9581 Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9582 Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000}; 9583 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9584 Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9585 Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000); 9586 # endif 9587 b= vec_any_lt (Iaux1.v, Iaux2.v); 9588 bAux= 0; 9589 for (i=0; i<4; i++) 9590 bAux= bAux || (Iaux1.e[i]<Iaux2.e[i]); 9591 if (bAux!=b) err= 1; 9592 9593 if (err) 9594 printf("Function vec_any_lt [type int] ===> Error\n"); 9595 else 9596 printf("Function vec_any_lt [type int] ===> OK\n"); 9597 9598 9599 err = 0; 9600 # if defined (GCC_COMPILER) 9601 UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9602 UIaux1.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9}; 9603 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9604 UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9605 UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9); 9606 # endif 9607 b= vec_any_lt (UIaux1.v, UIaux2.v); 9608 bAux= 0; 9609 for (i=0; i<4; i++) 9610 bAux= bAux || (UIaux1.e[i]<UIaux2.e[i]); 9611 if (bAux!=b) err= 1; 9612 9613 # if defined (GCC_COMPILER) 9614 UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9615 UIaux1.v= (vector unsigned int){0xFFFFFFF0, 12345678, 9, 9}; 9616 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9617 UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9618 UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 12345678, 9, 9); 9619 # endif 9620 b= vec_any_lt (UIaux1.v, UIaux2.v); 9621 bAux= 0; 9622 for (i=0; i<4; i++) 9623 bAux= bAux || (UIaux1.e[i]<UIaux2.e[i]); 9624 if (bAux!=b) err= 1; 9625 9626 # if defined (GCC_COMPILER) 9627 UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9628 UIaux1.v= (vector unsigned int){0xFFFFFFF0, 10000000, 9, 9}; 9629 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9630 UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9631 UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 10000000, 9, 9); 9632 # endif 9633 b= vec_any_lt (UIaux1.v, UIaux2.v); 9634 bAux= 0; 9635 for (i=0; i<4; i++) 9636 bAux= bAux || (UIaux1.e[i]<UIaux2.e[i]); 9637 if (bAux!=b) err= 1; 9638 9639 if (err) 9640 printf("Function vec_any_lt [type unsigned int] ===> Error\n"); 9641 else 9642 printf("Function vec_any_lt [type unsigned int] ===> OK\n"); 9643 9644 #if defined TEST_FLOATS 9645 err = 0; 9646 # if defined (GCC_COMPILER) 9647 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 9648 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 9649 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9650 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9651 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 9652 # endif 9653 b= vec_any_lt (Faux1.v, Faux2.v); 9654 bAux= 0; 9655 for (i=0; i<4; i++) 9656 bAux= bAux || (Faux1.e[i]<Faux2.e[i]); 9657 if (bAux!=b) err= 1; 9658 9659 # if defined (GCC_COMPILER) 9660 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 9661 Faux1.v= (vector float) { 0.0, 3.5, 0.5, -1.5}; 9662 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9663 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9664 Faux1.v= (vector float) ( 0.0, 3.5, 0.5, -1.5); 9665 # endif 9666 b= vec_any_lt (Faux1.v, Faux2.v); 9667 bAux= 0; 9668 for (i=0; i<4; i++) 9669 bAux= bAux || (Faux1.e[i]<Faux2.e[i]); 9670 if (bAux!=b) err= 1; 9671 9672 # if defined (GCC_COMPILER) 9673 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 9674 Faux1.v= (vector float) { 0.0, 3.5,-0.5, -1.5}; 9675 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9676 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 9677 Faux1.v= (vector float) ( 0.0, 3.5,-0.5, -1.5); 9678 # endif 9679 b= vec_any_lt (Faux1.v, Faux2.v); 9680 bAux= 0; 9681 for (i=0; i<4; i++) 9682 bAux= bAux || (Faux1.e[i]<Faux2.e[i]); 9683 if (bAux!=b) err= 1; 9684 9685 if (err) 9686 printf("Function vec_any_lt [type float] ===> Error\n"); 9687 else 9688 printf("Function vec_any_lt [type float] ===> OK\n"); 9689 #endif 9690 9691 9692 #if defined TEST_FLOATS 9693 /* Function vec_any_nan */ 9694 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 9695 err = 0; 9696 # if defined (GCC_COMPILER) 9697 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 9698 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9699 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 9700 # endif 9701 b= vec_any_nan (Faux1.v); 9702 bAux= 0; 9703 for (i=0; i<4; i++) 9704 bAux= bAux || isnan(Faux1.e[i]); 9705 if (bAux!=b) err= 1; 9706 9707 # if defined (GCC_COMPILER) 9708 Faux1.v= (vector float) { 0.0, 3.5, NAN, -1.5}; 9709 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9710 Faux1.v= (vector float) ( 0.0, 3.5, NAN, -1.5); 9711 # endif 9712 b= vec_any_nan (Faux1.v); 9713 bAux= 0; 9714 for (i=0; i<4; i++) 9715 bAux= bAux || isnan(Faux1.e[i]); 9716 if (bAux!=b) err= 1; 9717 9718 # if defined (GCC_COMPILER) 9719 Faux1.v= (vector float) { NAN, 3.5, NAN, -1.5}; 9720 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9721 Faux1.v= (vector float) ( NAN, 3.5, NAN, -1.5); 9722 # endif 9723 b= vec_any_nan (Faux1.v); 9724 bAux= 0; 9725 for (i=0; i<4; i++) 9726 bAux= bAux || isnan(Faux1.e[i]); 9727 if (bAux!=b) err= 1; 9728 9729 if (err) 9730 printf("Function vec_any_nan [type float] ===> Error\n"); 9731 else 9732 printf("Function vec_any_nan [type float] ===> OK\n"); 9733 #endif 9734 9735 9736 /* Function vec_any_ne */ 9737 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 9738 err = 0; 9739 # if defined (GCC_COMPILER) 9740 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9741 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9742 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9743 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9744 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9745 # endif 9746 b= vec_any_ne (Caux1.v, Caux2.v); 9747 bAux= 0; 9748 for (i=0; i<16; i++) 9749 bAux= bAux || (Caux1.e[i]!=Caux2.e[i]); 9750 if (bAux!=b) err= 1; 9751 9752 # if defined (GCC_COMPILER) 9753 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9754 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9755 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9756 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9757 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9758 # endif 9759 b= vec_any_ne (Caux1.v, Caux2.v); 9760 bAux= 0; 9761 for (i=0; i<16; i++) 9762 bAux= bAux || (Caux1.e[i]!=Caux2.e[i]); 9763 if (bAux!=b) err= 1; 9764 9765 # if defined (GCC_COMPILER) 9766 Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9767 Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}; 9768 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9769 Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9770 Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7); 9771 # endif 9772 b= vec_any_ne (Caux1.v, Caux2.v); 9773 bAux= 0; 9774 for (i=0; i<16; i++) 9775 bAux= bAux || (Caux1.e[i]!=Caux2.e[i]); 9776 if (bAux!=b) err= 1; 9777 9778 if (err) 9779 printf("Function vec_any_ne [type char] ===> Error\n"); 9780 else 9781 printf("Function vec_any_ne [type char] ===> OK\n"); 9782 9783 9784 err = 0; 9785 # if defined (GCC_COMPILER) 9786 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9787 UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9788 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9789 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9790 UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9791 # endif 9792 b= vec_any_ne (UCaux1.v, UCaux2.v); 9793 bAux= 0; 9794 for (i=0; i<16; i++) 9795 bAux= bAux || (UCaux1.e[i]!=UCaux2.e[i]); 9796 if (bAux!=b) err= 1; 9797 9798 # if defined (GCC_COMPILER) 9799 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9800 UCaux2.v= (vector unsigned char){200, 201, 206, 205, 0, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9801 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9802 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9803 UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 0, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9804 # endif 9805 b= vec_any_ne (UCaux1.v, UCaux2.v); 9806 bAux= 0; 9807 for (i=0; i<16; i++) 9808 bAux= bAux || (UCaux1.e[i]!=UCaux2.e[i]); 9809 if (bAux!=b) err= 1; 9810 9811 # if defined (GCC_COMPILER) 9812 UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9813 UCaux2.v= (vector unsigned char){200, 201, 206, 206, 0, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17}; 9814 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9815 UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9816 UCaux2.v= (vector unsigned char)(200, 201, 206, 206, 0, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17); 9817 # endif 9818 b= vec_any_ne (UCaux1.v, UCaux2.v); 9819 bAux= 0; 9820 for (i=0; i<16; i++) 9821 bAux= bAux || (UCaux1.e[i]!=UCaux2.e[i]); 9822 if (bAux!=b) err= 1; 9823 9824 if (err) 9825 printf("Function vec_any_ne [type unsigned char] ===> Error\n"); 9826 else 9827 printf("Function vec_any_ne [type unsigned char] ===> OK\n"); 9828 9829 9830 err = 0; 9831 # if defined (GCC_COMPILER) 9832 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9833 Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9834 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9835 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9836 Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9837 # endif 9838 b= vec_any_ne (Saux1.v, Saux2.v); 9839 bAux= 0; 9840 for (i=0; i<8; i++) 9841 bAux= bAux || (Saux1.e[i]!=Saux2.e[i]); 9842 if (bAux!=b) err= 1; 9843 9844 # if defined (GCC_COMPILER) 9845 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9846 Saux2.v= (vector signed short){-3800, 3700, -3600, -3500, 0, 3300, 3200, 3100}; 9847 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9848 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9849 Saux2.v= (vector signed short)(-3800, 3700, -3600, -3500, 0, 3300, 3200, 3100); 9850 # endif 9851 b= vec_any_ne (Saux1.v, Saux2.v); 9852 bAux= 0; 9853 for (i=0; i<8; i++) 9854 bAux= bAux || (Saux1.e[i]!=Saux2.e[i]); 9855 if (bAux!=b) err= 1; 9856 9857 # if defined (GCC_COMPILER) 9858 Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100}; 9859 Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3100, 3100}; 9860 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9861 Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100); 9862 Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3100, 3100); 9863 # endif 9864 b= vec_any_ne (Saux1.v, Saux2.v); 9865 bAux= 0; 9866 for (i=0; i<8; i++) 9867 bAux= bAux || (Saux1.e[i]!=Saux2.e[i]); 9868 if (bAux!=b) err= 1; 9869 9870 if (err) 9871 printf("Function vec_any_ne [type short] ===> Error\n"); 9872 else 9873 printf("Function vec_any_ne [type short] ===> OK\n"); 9874 9875 9876 err = 0; 9877 # if defined (GCC_COMPILER) 9878 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9879 USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9880 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9881 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9882 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9883 # endif 9884 b= vec_any_ne (USaux1.v, USaux2.v); 9885 bAux= 0; 9886 for (i=0; i<8; i++) 9887 bAux= bAux || (USaux1.e[i]!=USaux2.e[i]); 9888 if (bAux!=b) err= 1; 9889 9890 # if defined (GCC_COMPILER) 9891 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9892 USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3100, 3100}; 9893 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9894 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9895 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3100, 3100); 9896 # endif 9897 b= vec_any_ne (USaux1.v, USaux2.v); 9898 bAux= 0; 9899 for (i=0; i<8; i++) 9900 bAux= bAux || (USaux1.e[i]!=USaux2.e[i]); 9901 if (bAux!=b) err= 1; 9902 9903 # if defined (GCC_COMPILER) 9904 USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100}; 9905 USaux2.v= (vector unsigned short){48000, 47000, 46000, 0, 0, 3300, 3100, 3100}; 9906 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9907 USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100); 9908 USaux2.v= (vector unsigned short)(48000, 47000, 46000, 0, 0, 3300, 3100, 3100); 9909 # endif 9910 b= vec_any_ne (USaux1.v, USaux2.v); 9911 bAux= 0; 9912 for (i=0; i<8; i++) 9913 bAux= bAux || (USaux1.e[i]!=USaux2.e[i]); 9914 if (bAux!=b) err= 1; 9915 9916 if (err) 9917 printf("Function vec_any_ne [type unsigned short] ===> Error\n"); 9918 else 9919 printf("Function vec_any_ne [type unsigned short] ===> OK\n"); 9920 9921 9922 err = 0; 9923 # if defined (GCC_COMPILER) 9924 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9925 Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9926 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9927 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9928 Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9929 # endif 9930 b= vec_any_ne (Iaux1.v, Iaux2.v); 9931 bAux= 0; 9932 for (i=0; i<4; i++) 9933 bAux= bAux || (Iaux1.e[i]!=Iaux2.e[i]); 9934 if (bAux!=b) err= 1; 9935 9936 # if defined (GCC_COMPILER) 9937 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9938 Iaux2.v= (vector signed int){-1003800, -1003700, 0,1113300}; 9939 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9940 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9941 Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1113300); 9942 # endif 9943 b= vec_any_ne (Iaux1.v, Iaux2.v); 9944 bAux= 0; 9945 for (i=0; i<4; i++) 9946 bAux= bAux || (Iaux1.e[i]!=Iaux2.e[i]); 9947 if (bAux!=b) err= 1; 9948 9949 # if defined (GCC_COMPILER) 9950 Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300}; 9951 Iaux2.v= (vector signed int){-1003800, 10, 0,1113300}; 9952 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9953 Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300); 9954 Iaux2.v= (vector signed int)(-1003800, 10, 0,1113300); 9955 # endif 9956 b= vec_any_ne (Iaux1.v, Iaux2.v); 9957 bAux= 0; 9958 for (i=0; i<4; i++) 9959 bAux= bAux || (Iaux1.e[i]!=Iaux2.e[i]); 9960 if (bAux!=b) err= 1; 9961 9962 if (err) 9963 printf("Function vec_any_ne [type int] ===> Error\n"); 9964 else 9965 printf("Function vec_any_ne [type int] ===> OK\n"); 9966 9967 9968 err = 0; 9969 # if defined (GCC_COMPILER) 9970 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9971 UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9972 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9973 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9974 UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9975 # endif 9976 b= vec_any_ne (UIaux1.v, UIaux2.v); 9977 bAux= 0; 9978 for (i=0; i<4; i++) 9979 bAux= bAux || (UIaux1.e[i]!=UIaux2.e[i]); 9980 if (bAux!=b) err= 1; 9981 9982 # if defined (GCC_COMPILER) 9983 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9984 UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 5, 1}; 9985 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9986 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 9987 UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 5, 1); 9988 # endif 9989 b= vec_any_ne (UIaux1.v, UIaux2.v); 9990 bAux= 0; 9991 for (i=0; i<4; i++) 9992 bAux= bAux || (UIaux1.e[i]!=UIaux2.e[i]); 9993 if (bAux!=b) err= 1; 9994 9995 # if defined (GCC_COMPILER) 9996 UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1}; 9997 UIaux2.v= (vector unsigned int){0xFFFFFFF0, 12345678, 5, 1}; 9998 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 9999 UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1); 10000 UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 12345678, 5, 1); 10001 # endif 10002 b= vec_any_ne (UIaux1.v, UIaux2.v); 10003 bAux= 0; 10004 for (i=0; i<4; i++) 10005 bAux= bAux || (UIaux1.e[i]!=UIaux2.e[i]); 10006 if (bAux!=b) err= 1; 10007 10008 if (err) 10009 printf("Function vec_any_ne [type unsigned int] ===> Error\n"); 10010 else 10011 printf("Function vec_any_ne [type unsigned int] ===> OK\n"); 10012 10013 #if defined TEST_FLOATS 10014 err = 0; 10015 # if defined (GCC_COMPILER) 10016 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 10017 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 10018 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10019 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 10020 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 10021 # endif 10022 b= vec_any_ne (Faux1.v, Faux2.v); 10023 bAux= 0; 10024 for (i=0; i<4; i++) 10025 bAux= bAux || (Faux1.e[i]!=Faux2.e[i]); 10026 if (bAux!=b) err= 1; 10027 10028 # if defined (GCC_COMPILER) 10029 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 10030 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.998}; 10031 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10032 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 10033 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.998); 10034 # endif 10035 b= vec_any_ne (Faux1.v, Faux2.v); 10036 bAux= 0; 10037 for (i=0; i<4; i++) 10038 bAux= bAux || (Faux1.e[i]!=Faux2.e[i]); 10039 if (bAux!=b) err= 1; 10040 10041 # if defined (GCC_COMPILER) 10042 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 10043 Faux2.v= (vector float) {-1.5, 0.0, 0.5, -3.998}; 10044 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10045 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 10046 Faux2.v= (vector float) (-1.5, 0.0, 0.5, -3.998); 10047 # endif 10048 b= vec_any_ne (Faux1.v, Faux2.v); 10049 bAux= 0; 10050 for (i=0; i<4; i++) 10051 bAux= bAux || (Faux1.e[i]!=Faux2.e[i]); 10052 if (bAux!=b) err= 1; 10053 10054 if (err) 10055 printf("Function vec_any_ne [type float] ===> Error\n"); 10056 else 10057 printf("Function vec_any_ne [type float] ===> OK\n"); 10058 #endif 10059 10060 10061 #if defined TEST_FLOATS 10062 /* Function vec_any_nge */ 10063 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 10064 err = 0; 10065 # if defined (GCC_COMPILER) 10066 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10067 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 10068 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10069 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10070 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 10071 # endif 10072 b= vec_any_nge (Faux1.v, Faux2.v); 10073 bAux= 0; 10074 for (i=0; i<4; i++) 10075 bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 10076 (Faux1.e[i]<Faux2.e[i]); 10077 if (bAux!=b) err= 1; 10078 10079 # if defined (GCC_COMPILER) 10080 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10081 Faux2.v= (vector float) {-1.5, 1.0, 0.55, -3.999}; 10082 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10083 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10084 Faux2.v= (vector float) (-1.5, 1.0, 0.55, -3.999); 10085 # endif 10086 b= vec_any_nge (Faux1.v, Faux2.v); 10087 bAux= 0; 10088 for (i=0; i<4; i++) 10089 bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 10090 (Faux1.e[i]<Faux2.e[i]); 10091 if (bAux!=b) err= 1; 10092 10093 # if defined (GCC_COMPILER) 10094 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10095 Faux2.v= (vector float) {-1.5, 5.0, 0.5, -3.999}; 10096 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10097 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10098 Faux2.v= (vector float) (-1.5, 5.0, 0.5, -3.999); 10099 # endif 10100 b= vec_any_nge (Faux1.v, Faux2.v); 10101 bAux= 0; 10102 for (i=0; i<4; i++) 10103 bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 10104 (Faux1.e[i]<Faux2.e[i]); 10105 if (bAux!=b) err= 1; 10106 10107 # if defined (GCC_COMPILER) 10108 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10109 Faux2.v= (vector float) {-1.5, 1.0, NAN, -3.999}; 10110 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10111 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10112 Faux2.v= (vector float) (-1.5, 1.0, NAN, -3.999); 10113 # endif 10114 b= vec_any_nge (Faux1.v, Faux2.v); 10115 bAux= 0; 10116 for (i=0; i<4; i++) 10117 bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 10118 (Faux1.e[i]<Faux2.e[i]); 10119 if (bAux!=b) err= 1; 10120 10121 if (err) 10122 printf("Function vec_any_nge [type float] ===> Error\n"); 10123 else 10124 printf("Function vec_any_nge [type float] ===> OK\n"); 10125 #endif 10126 10127 10128 #if defined TEST_FLOATS 10129 /* Function vec_any_ngt */ 10130 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 10131 err = 0; 10132 # if defined (GCC_COMPILER) 10133 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10134 Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 10135 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10136 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10137 Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 10138 # endif 10139 b= vec_any_ngt (Faux1.v, Faux2.v); 10140 bAux= 0; 10141 for (i=0; i<4; i++) 10142 bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 10143 !(Faux1.e[i]>Faux2.e[i]); 10144 if (bAux!=b) err= 1; 10145 10146 # if defined (GCC_COMPILER) 10147 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10148 Faux2.v= (vector float) {-1.5, 1.0, 0.55, -3.999}; 10149 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10150 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10151 Faux2.v= (vector float) (-1.5, 1.0, 0.55, -3.999); 10152 # endif 10153 b= vec_any_ngt (Faux1.v, Faux2.v); 10154 bAux= 0; 10155 for (i=0; i<4; i++) 10156 bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 10157 !(Faux1.e[i]>Faux2.e[i]); 10158 if (bAux!=b) err= 1; 10159 10160 # if defined (GCC_COMPILER) 10161 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10162 Faux2.v= (vector float) {-1.5, 5.0, 0.5, -3.999}; 10163 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10164 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10165 Faux2.v= (vector float) (-1.5, 5.0, 0.5, -3.999); 10166 # endif 10167 b= vec_any_ngt (Faux1.v, Faux2.v); 10168 bAux= 0; 10169 for (i=0; i<4; i++) 10170 bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 10171 !(Faux1.e[i]>Faux2.e[i]); 10172 if (bAux!=b) err= 1; 10173 10174 # if defined (GCC_COMPILER) 10175 Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10176 Faux2.v= (vector float) {-1.5, 1.0, NAN, -3.999}; 10177 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10178 Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10179 Faux2.v= (vector float) (-1.5, 1.0, NAN, -3.999); 10180 # endif 10181 b= vec_any_ngt (Faux1.v, Faux2.v); 10182 bAux= 0; 10183 for (i=0; i<4; i++) 10184 bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || 10185 !(Faux1.e[i]>Faux2.e[i]); 10186 if (bAux!=b) err= 1; 10187 10188 if (err) 10189 printf("Function vec_any_ngt [type float] ===> Error\n"); 10190 else 10191 printf("Function vec_any_ngt [type float] ===> OK\n"); 10192 #endif 10193 10194 10195 #if defined TEST_FLOATS 10196 /* Function vec_any_nle */ 10197 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 10198 err = 0; 10199 # if defined (GCC_COMPILER) 10200 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 10201 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10202 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10203 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 10204 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10205 # endif 10206 b= vec_any_nle (Faux1.v, Faux2.v); 10207 bAux= 0; 10208 for (i=0; i<4; i++) 10209 bAux= bAux || 10210 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<=Faux2.e[i])); 10211 if (bAux!=b) err= 1; 10212 10213 # if defined (GCC_COMPILER) 10214 Faux1.v= (vector float) {-1.5, 1.0, 0.55, -3.999}; 10215 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10216 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10217 Faux1.v= (vector float) (-1.5, 1.0, 0.55, -3.999); 10218 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10219 # endif 10220 b= vec_any_nle (Faux1.v, Faux2.v); 10221 bAux= 0; 10222 for (i=0; i<4; i++) 10223 bAux= bAux || 10224 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<=Faux2.e[i])); 10225 if (bAux!=b) err= 1; 10226 10227 # if defined (GCC_COMPILER) 10228 Faux1.v= (vector float) {-1.5, 5.0, 0.5, -3.999}; 10229 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10230 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10231 Faux1.v= (vector float) (-1.5, 5.0, 0.5, -3.999); 10232 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10233 # endif 10234 b= vec_any_nle (Faux1.v, Faux2.v); 10235 bAux= 0; 10236 for (i=0; i<4; i++) 10237 bAux= bAux || 10238 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<=Faux2.e[i])); 10239 if (bAux!=b) err= 1; 10240 10241 # if defined (GCC_COMPILER) 10242 Faux1.v= (vector float) {-1.5, 1.0, NAN, -3.999}; 10243 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10244 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10245 Faux1.v= (vector float) (-1.5, 1.0, NAN, -3.999); 10246 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10247 # endif 10248 b= vec_any_nle (Faux1.v, Faux2.v); 10249 bAux= 0; 10250 for (i=0; i<4; i++) 10251 bAux= bAux || 10252 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<=Faux2.e[i])); 10253 if (bAux!=b) err= 1; 10254 10255 if (err) 10256 printf("Function vec_any_nle [type float] ===> Error\n"); 10257 else 10258 printf("Function vec_any_nle [type float] ===> OK\n"); 10259 #endif 10260 10261 10262 #if defined TEST_FLOATS 10263 /* Function vec_any_nlt */ 10264 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 10265 err = 0; 10266 # if defined (GCC_COMPILER) 10267 Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999}; 10268 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10269 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10270 Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999); 10271 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10272 # endif 10273 b= vec_any_nlt (Faux1.v, Faux2.v); 10274 bAux= 0; 10275 for (i=0; i<4; i++) 10276 bAux= bAux || 10277 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<Faux2.e[i])); 10278 if (bAux!=b) err= 1; 10279 10280 # if defined (GCC_COMPILER) 10281 Faux1.v= (vector float) {-1.5, 1.0, 0.55, -3.999}; 10282 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10283 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10284 Faux1.v= (vector float) (-1.5, 1.0, 0.55, -3.999); 10285 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10286 # endif 10287 b= vec_all_nlt (Faux1.v, Faux2.v); 10288 b= vec_any_nlt (Faux1.v, Faux2.v); 10289 bAux= 0; 10290 for (i=0; i<4; i++) 10291 bAux= bAux || 10292 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<Faux2.e[i])); 10293 if (bAux!=b) err= 1; 10294 10295 # if defined (GCC_COMPILER) 10296 Faux1.v= (vector float) {-1.5, 5.0, 0.5, -3.999}; 10297 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10298 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10299 Faux1.v= (vector float) (-1.5, 5.0, 0.5, -3.999); 10300 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10301 # endif 10302 b= vec_any_nlt (Faux1.v, Faux2.v); 10303 bAux= 0; 10304 for (i=0; i<4; i++) 10305 bAux= bAux || 10306 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<Faux2.e[i])); 10307 if (bAux!=b) err= 1; 10308 10309 # if defined (GCC_COMPILER) 10310 Faux1.v= (vector float) {-1.5, 1.0, NAN, -3.999}; 10311 Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5}; 10312 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10313 Faux1.v= (vector float) (-1.5, 1.0, NAN, -3.999); 10314 Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5); 10315 # endif 10316 b= vec_any_nlt (Faux1.v, Faux2.v); 10317 bAux= 0; 10318 for (i=0; i<4; i++) 10319 bAux= bAux || 10320 (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<Faux2.e[i])); 10321 if (bAux!=b) err= 1; 10322 10323 if (err) 10324 printf("Function vec_any_nlt [type float] ===> Error\n"); 10325 else 10326 printf("Function vec_any_nlt [type float] ===> OK\n"); 10327 #endif 10328 10329 10330 #if defined TEST_FLOATS 10331 /* Function vec_any_numeric */ 10332 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 10333 err = 0; 10334 # if defined (GCC_COMPILER) 10335 Faux1.v= (vector float) { NAN, NAN, NAN, NAN}; 10336 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10337 Faux1.v= (vector float) ( NAN, NAN, NAN, NAN); 10338 # endif 10339 b= vec_any_numeric (Faux1.v); 10340 bAux= 0; 10341 for (i=0; i<4; i++) 10342 bAux= bAux || !isnan(Faux1.e[i]); 10343 if (bAux!=b) err= 1; 10344 10345 # if defined (GCC_COMPILER) 10346 Faux1.v= (vector float) { NAN, 3.5, NAN, NAN}; 10347 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10348 Faux1.v= (vector float) ( NAN, 3.5, NAN, NAN); 10349 # endif 10350 b= vec_any_numeric (Faux1.v); 10351 bAux= 0; 10352 for (i=0; i<4; i++) 10353 bAux= bAux || !isnan(Faux1.e[i]); 10354 if (bAux!=b) err= 1; 10355 10356 # if defined (GCC_COMPILER) 10357 Faux1.v= (vector float) { -1.5, 3.5, 0.55, -1.5}; 10358 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10359 Faux1.v= (vector float) ( -1.5, 3.5, 0.55, -1.5); 10360 # endif 10361 b= vec_any_numeric (Faux1.v); 10362 bAux= 0; 10363 for (i=0; i<4; i++) 10364 bAux= bAux || !isnan(Faux1.e[i]); 10365 if (bAux!=b) err= 1; 10366 10367 if (err) 10368 printf("Function vec_any_numeric [type float] ===> Error\n"); 10369 else 10370 printf("Function vec_any_numeric [type float] ===> OK\n"); 10371 #endif 10372 10373 10374 #if defined TEST_FLOATS 10375 /* Function vec_any_out */ 10376 printf("\n:::::::::::::::::::::::::::::::::::::::\n"); 10377 err = 0; 10378 Faux1.v = Fcons1; 10379 Faux2.v = Fcons2; 10380 I1 = vec_any_out( Faux1.v, Faux2.v ); 10381 Iaux = 0; 10382 for ( i=0; i< 4; i++ ) 10383 { 10384 Iaux = Iaux || ((isnan(Faux1.e[i])) || (isnan(Faux2.e[i])) || 10385 (Faux1.e[i]>Faux2.e[i]) || (Faux1.e[i]<-Faux2.e[i])); 10386 } 10387 if (I1 != Iaux) err++; 10388 10389 # if defined (GCC_COMPILER) 10390 Faux1.v = (vector float){-0.5, 1.0, 0, -0.999}; 10391 # elif defined (MAC_COMPILER) || defined (XLC_COMPILER) 10392 Faux1.v = (vector float)(-0.5, 1.0, 0, -0.999); 10393 # endif 10394 Faux2.v = Fcons2; 10395 I1 = vec_any_out( Faux1.v, Faux2.v ); 10396 Iaux = 0; 10397 for ( i=0; i< 4; i++ ) 10398 { 10399 Iaux = Iaux || ((isnan(Faux1.e[i])) || (isnan(Faux2.e[i])) || 10400 (Faux1.e[i]>Faux2.e[i]) || (Faux1.e[i]<-Faux2.e[i])); 10401 } 10402 if (I1 != Iaux) err++; 10403 10404 if (err) 10405 printf("Function vec_any_out [type float] ===> Error\n"); 10406 else 10407 printf("Function vec_any_out [type float] ===> OK\n"); 10408 #endif 10409 10410 return 0; 10411 } 10412
