l4/pkg/valgrind/src/valgrind-3.6.0-svn/none/tests/ppc32/testVMX.c

   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@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@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@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 }