--- /dev/null
+
+/* HOW TO COMPILE:
+
+ gcc -O -g -Wall -maltivec -mabi=altivec -DALTIVEC -DGCC_COMPILER
+ testVMX.c -o testVMX
+
+*/
+
+/*
+ * testVMX - A test program to check the correctness of VMX instructions
+ *
+ * Copyright (C) 2004 CEPBA-IBM Research Institute
+ *
+ * Authors: Jose Maria Cela, Raul de la Cruz,
+ * Rogeli Grima, Xavier Saez <blade_support@ciri.upc.es>
+ *
+ * Web page: http://www.ciri.upc.es/cela_pblade/
+ *
+ * This file is part of testVMX.
+ *
+ * testVMX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * testVMX is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with testVMX; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 US
+ */
+
+/*
+ * Version 0.2.2 2004/09/02
+ * Removed some not useful flags for compilation and changed the GPL license
+ * header updating the contact email and adding the web page URL
+ *
+ * Version 0.2.1 2004/07/07
+ * Some flags added in Makefile for XLC compilation (-qalias, -qinline)
+ *
+ * Version 0.2 2004/07/02
+ * Makefile and testVMX.c patched to compile with SLES 9 (Linux - GCC 3.3.3),
+ * IBM XLC Enterprise Edition and MacOS X 10.3 (Darwin - GCC 3.3)
+ *
+ * Version 0.1 2004/03/05
+ * First public version release
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <limits.h>
+#include <string.h>
+
+/* Calloc for align data to 16 bytes boundaries */
+
+/* ----------- BEGIN #include "memoryVector.h" ----------- */
+
+/*
+ * testVMX - A test program to check the correctness of VMX instructions
+ *
+ * Copyright (C) 2004 CEPBA-IBM Research Institute
+ *
+ * Authors: Jose Maria Cela, Raul de la Cruz,
+ * Rogeli Grima, Xavier Saez <blade_support@ciri.upc.es>
+ *
+ * Web page: http://www.ciri.upc.es/cela_pblade/
+ *
+ * This file is part of testVMX.
+ *
+ * testVMX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * testVMX is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with testVMX; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 US
+ */
+
+#ifndef MEMORY_VECTOR_H
+# define MEMORY_VECTOR_H
+
+# include <stdlib.h>
+
+ void *calloc_vec( size_t nmemb, size_t size );
+ void free_vec( void *ptr );
+
+#endif
+
+/* ----------- END #include "memoryVector.h" ----------- */
+
+/* ----------- BEGIN #include "memoryVector.c" ----------- */
+
+/*
+ * testVMX - A test program to check the correctness of VMX instructions
+ *
+ * Copyright (C) 2004 CEPBA-IBM Research Institute
+ *
+ * Authors: Jose Maria Cela, Raul de la Cruz,
+ * Rogeli Grima, Xavier Saez <blade_support@ciri.upc.es>
+ *
+ * Web page: http://www.ciri.upc.es/cela_pblade/
+ *
+ * This file is part of testVMX.
+ *
+ * testVMX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * testVMX is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with testVMX; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 US
+ */
+
+#include <stdio.h>
+#include <string.h>
+/* #include "memoryVector.h"*/
+
+typedef struct
+ {
+ char *realAdd;
+ char *returnAdd;
+ } Tmemtab;
+
+
+static Tmemtab *memTab = NULL;
+static size_t nadd = 0;
+static size_t MAX_N_ADD = 100;
+
+
+void *calloc_vec( size_t nmemb, size_t size )
+{
+/* ---------------------------------------------------------- Local Variables */
+ char *realadd;
+ char *retadd;
+ size_t nbytes, cc, rr;
+
+/* -------------------------------------------------------------------- BEGIN */
+ if (memTab == (Tmemtab*)NULL)
+ {
+ memTab = (Tmemtab *) malloc( MAX_N_ADD*sizeof(Tmemtab) );
+ if (memTab == (Tmemtab*)NULL)
+ {
+ fprintf(stderr, "\n------------ FATAL ERRROR ------------------\n");
+ fprintf(stderr, "Memory table out of memory\n");
+ return NULL;
+ }
+ }
+
+ /* 16 extra bytes are allocated for adjust alignement */
+ nbytes = (size*nmemb)+16;
+
+ /* Alloc a block of 'nbytes' */
+ realadd = (char *) malloc( nbytes );
+ if (realadd == (char *)NULL)
+ {
+ fprintf(stderr, "\n------------ FATAL ERRROR ------------------\n");
+ fprintf(stderr, "Out of memory\n");
+ return NULL;
+ }
+
+ memset( realadd, 0, nbytes );
+
+ cc = ((size_t)realadd)/16;
+ rr = ((size_t)realadd)%16;
+ if (rr == 0)
+ retadd = realadd;
+ else
+ retadd = (char *)((cc+1)*16);
+
+ if (nadd == MAX_N_ADD)
+ {
+ MAX_N_ADD += 100;
+ memTab = (Tmemtab*) realloc( memTab, MAX_N_ADD*sizeof(Tmemtab) );
+ if (memTab == (Tmemtab*)NULL)
+ {
+ free( realadd );
+ fprintf(stderr, "\n------------ FATAL ERRROR ------------------\n");
+ fprintf(stderr, "Memory table out of memory\n");
+ return NULL;
+ }
+ }
+
+ memTab[nadd].realAdd = realadd;
+ memTab[nadd].returnAdd = retadd;;
+ nadd++;
+
+ return (void*)retadd;
+/* ---------------------------------------------------------------------- END */
+}
+
+
+void free_vec( void *ptr )
+{
+/* ---------------------------------------------------------- Local Variables */
+ int ii, pos;
+
+/* -------------------------------------------------------------------- BEGIN */
+ pos = -1;
+ for (ii= 0; ii< nadd; ii++)
+ if (memTab[ii].returnAdd == ptr)
+ {
+ pos = ii;
+ break;
+ }
+
+ if (pos == -1)
+ {
+ fprintf(stderr, "\n------------ WARNING ------------------------\n");
+ fprintf(stderr, "Pointer not found in memory table\n\n");
+ }
+ else
+ {
+ free( memTab[ii].realAdd );
+
+ for (ii= pos+1; ii< nadd; ii++)
+ memTab[ii-1] = memTab[ii];
+ nadd--;
+
+ if (nadd == 0)
+ {
+ free( memTab );
+ memTab = NULL;
+ MAX_N_ADD = 100;
+ }
+ }
+/* ---------------------------------------------------------------------- END */
+}
+
+
+/* ----------- END #include "memoryVector.c" ----------- */
+
+
+#ifdef ALTIVEC
+# ifdef GCC_COMPILER
+# include <altivec.h>
+# endif
+
+
+
+//#define TEST_FLOATS
+
+
+
+/* Redefinition for undefined NAN and xlC compiling C++ code */
+# if !defined(NAN) || ( defined(__IBMCPP__) && defined(XLC_COMPILER) )
+# undef NAN
+# define NAN 0x7FC00000
+/* # define NAN 0xFFFA5A5A
+ * # define NAN 0x80000000
+ * # define NAN 0x00008000
+ */
+# endif
+
+
+int part1( );
+int part2( );
+int part3( );
+int part4( );
+int part5( );
+
+
+typedef union
+{
+ vector signed char v;
+ signed char e[16];
+} TvecChar;
+
+typedef union
+{
+ vector unsigned char v;
+ unsigned char e[16];
+} TvecUChar;
+
+typedef union
+{
+ vector bool char v;
+ unsigned char e[16];
+} TvecBChar;
+
+typedef union
+{
+ vector signed short v;
+ signed short e[8];
+} TvecShort;
+
+typedef union
+{
+ vector unsigned short v;
+ unsigned short e[8];
+} TvecUShort;
+
+typedef union
+{
+ vector bool short v;
+ unsigned short e[8];
+} TvecBShort;
+
+typedef union
+{
+ vector signed int v;
+ signed int e[4];
+} TvecInt;
+
+typedef union
+{
+ vector unsigned int v;
+ unsigned int e[4];
+} TvecUInt;
+
+typedef union
+{
+ vector bool int v;
+ unsigned int e[4];
+} TvecBInt;
+
+#if defined TEST_FLOATS
+typedef union
+{
+ vector float v;
+ float e[4];
+ signed int i[4];
+} TvecFloat;
+#endif
+
+/* Scalar bool types declaration */
+typedef unsigned char TboolChar;
+typedef unsigned short TboolShort;
+typedef unsigned int TboolInt;
+
+#endif
+
+
+
+
+
+
+/**********************************************************************
+ Main()
+ **********************************************************************/
+
+
+
+int main()
+{
+ TvecChar Caux1, Caux2, Caux3;//, Caux4;
+ TvecUChar UCaux1, UCaux2, UCaux3;//, UCaux4;
+ TvecBChar BCaux1;//, BCaux2, BCaux3, BCaux4;
+ TvecShort Saux1, Saux2, Saux3;//, Saux4;
+ TvecUShort USaux1, USaux2, USaux3;//, USaux4;
+ TvecBShort BSaux1;//, BSaux2, BSaux3, BSaux4;
+ TvecInt Iaux1, Iaux2, Iaux3;//, Iaux4;
+ TvecUInt UIaux1, UIaux2, UIaux3;//, UIaux4;
+ TvecBInt BIaux1;//, BIaux2, BIaux3, BIaux4;
+#if defined TEST_FLOATS
+ TvecFloat Faux1, Faux2, Faux3;//, Faux4;
+#endif
+
+ int i, err, j;//, b, bAux;
+#if defined TEST_FLOATS
+ int b;
+ signed int Ivec1, Ivec2, Ivec3;
+#endif
+
+// unsigned char *UCvec1;
+// signed short *Svec1;
+// unsigned short *USvec1;
+// unsigned int *UIvec1;
+#if defined TEST_FLOATS
+// float *Fvec1;
+#endif
+
+ /* For saturated rutines */
+// long long int LLaux;
+
+ signed char Caux;
+ unsigned char UCaux;
+ signed short Saux;
+ unsigned short USaux;
+ signed int Iaux;//, I1, I2;
+ unsigned int UIaux;//, UI1, UI2;
+#if defined TEST_FLOATS
+ float Faux;
+#endif
+
+ /* Scalar bool types definition */
+ TboolChar BCaux;
+ TboolShort BSaux;
+ TboolInt BIaux;
+
+/*
+ union
+ {
+ float f;
+ signed int si;
+ unsigned int ui;
+ signed short ss[2];
+ unsigned short us[2];
+ signed char sc[4];
+ unsigned char uc[4];
+ } INTunion1, INTunion2;
+
+ union
+ {
+ signed short ss;
+ unsigned short us;
+ signed char sc[2];
+ unsigned char uc[2];
+ } SHOunion1, SHOunion2;
+*/
+
+#if defined (GCC_COMPILER)
+ vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127};
+ vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+ vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
+ vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3};
+ vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000};
+ vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767};
+ vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3};
+ vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1};
+ vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4};
+ vector signed int Icons1 = (vector signed int){-4, -1, 1, 4};
+ vector signed int Icons2 = (vector signed int){1, 1, 1, 1};
+ vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF};
+ vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1};
+ vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1};
+ vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2};
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999};
+ vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0};
+ vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0};
+#endif
+
+#elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+ vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127);
+ vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
+ vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+ vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3);
+ vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000);
+ vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767);
+ vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3);
+ vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1);
+ vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4);
+ vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4);
+ vector signed int Icons2 = (vector signed int)(1, 1, 1, 1);
+ vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF);
+ vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1);
+ vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1);
+ vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2);
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999);
+ vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0);
+ vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0);
+#endif
+
+#endif
+
+
+/* Function vec_abs */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_abs( Ccons1 );
+ Caux2.v = Ccons1;
+ for( i=0; i< 16; i++ )
+ if (Caux1.e[i] != abs( Caux2.e[i] ))
+ err++;
+ if (err)
+ printf("Function vec_abs [type char] ===> Error\n");
+ else
+ printf("Function vec_abs [type char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_abs( Scons1 );
+ Saux2.v = Scons1;
+ for( i=0; i< 8; i++ )
+ if (Saux1.e[i] != abs( Saux2.e[i] ))
+ err++;
+ if (err)
+ printf("Function vec_abs [type short] ===> Error\n");
+ else
+ printf("Function vec_abs [type short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_abs( Icons1 );
+ Iaux2.v = Icons1;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != abs( Iaux2.e[i] ))
+ err++;
+ if (err)
+ printf("Function vec_abs [type integer] ===> Error\n");
+ else
+ printf("Function vec_abs [type integer] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_abs( Fcons1 );
+ Faux2.v = Fcons1;
+ for( i=0; i< 4; i++ )
+ if (Faux1.e[i] != fabs( Faux2.e[i] ))
+ err++;
+ if (err)
+ printf("Function vec_abs [type float] ===> Error\n");
+ else
+ printf("Function vec_abs [type float] ===> OK\n");
+#endif
+
+/* Function vec_abss */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_abss( Ccons1 );
+ Caux2.v = Ccons1;
+ for( i=0; i< 16; i++ )
+ if (Caux1.e[i] != abs( Caux2.e[i] ))
+ err++;
+ if (err)
+ printf("Function vec_abss [type char] ===> Error\n");
+ else
+ printf("Function vec_abss [type char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_abss( Scons1 );
+ Saux2.v = Scons1;
+ for( i=0; i< 8; i++ )
+ if (Saux1.e[i] != abs( Saux2.e[i] ))
+ err++;
+ if (err)
+ printf("Function vec_abss [type short] ===> Error\n");
+ else
+ printf("Function vec_abss [type short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_abss( Icons1 );
+ Iaux2.v = Icons1;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != abs( Iaux2.e[i] ))
+ err++;
+ if (err)
+ printf("Function vec_abss [type integer] ===> Error\n");
+ else
+ printf("Function vec_abss [type integer] ===> OK\n");
+
+/* Function vec_add */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_add( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ {
+ Caux = Caux2.e[i]+Caux3.e[i];
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_add [type char] ===> Error\n");
+ else
+ printf("Function vec_add [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_add( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux2.e[i]+UCaux3.e[i];
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_add [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_add [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_add( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ Saux = Saux2.e[i]+Saux3.e[i];
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_add [type short] ===> Error\n");
+ else
+ printf("Function vec_add [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_add( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = USaux2.e[i]+USaux3.e[i];
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_add [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_add [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_add( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i]+Iaux3.e[i];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_add [type integer] ===> Error\n");
+ else
+ printf("Function vec_add [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_add( UIcons1, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = UIaux2.e[i]+UIaux3.e[i];
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_add [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_add [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_add( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ Faux = Faux2.e[i]+Faux3.e[i];
+ if (Faux1.e[i] != Faux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_add [type float] ===> Error\n");
+ else
+ printf("Function vec_add [type float] ===> OK\n");
+#endif
+
+
+/* Function vec_addc */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UIaux1.v = vec_addc( UIcons1, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = (unsigned int)(UIaux2.e[i]+UIaux3.e[i]);
+ if ((UIaux< UIaux2.e[i]) || (UIaux< UIaux3.e[i]))
+ UIaux=1;
+ else
+ UIaux=0;
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_addc [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_addc [type unsigned int] ===> OK\n");
+
+/* Function vec_adds */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_adds( Ccons1, Ccons3 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons3;
+ for( i=0; i< 16; i++ )
+ {
+ Caux = Caux2.e[i]+Caux3.e[i];
+ if ((Caux2.e[i]>0)&&(Caux3.e[i]>0))
+ {
+ if (Caux< 0)
+ Caux=0x7F;
+ }
+ else if ((Caux2.e[i]<0)&&(Caux3.e[i]<0))
+ {
+ if (Caux> 0)
+ Caux=0x80;
+ }
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_adds [type char] ===> Error\n");
+ else
+ printf("Function vec_adds [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_adds( UCcons1, UCcons3 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = (unsigned char)(UCaux2.e[i]+UCaux3.e[i]);
+ if ((UCaux< UCaux2.e[i]) || (UCaux< UCaux3.e[i]))
+ UCaux=0xFF;
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_adds [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_adds [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_adds( Scons1, Scons3 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons3;
+ for( i=0; i< 8; i++ )
+ {
+ Saux = Saux2.e[i]+Saux3.e[i];
+ if ((Saux2.e[i]>0)&&(Saux3.e[i]>0))
+ {
+ if (Saux< 0)
+ Saux=0x7FFF;
+ }
+ else if ((Saux2.e[i]<0)&&(Saux3.e[i]<0))
+ {
+ if (Saux> 0)
+ Saux=0x8000;
+ }
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_adds [type short] ===> Error\n");
+ else
+ printf("Function vec_adds [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_adds( UScons1, UScons3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = (unsigned short)(USaux2.e[i]+USaux3.e[i]);
+ if ((USaux< USaux2.e[i]) || (USaux< USaux3.e[i]))
+ USaux=0xFFFF;
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_adds [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_adds [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+ Iaux1.v = vec_adds( Icons1, Icons3 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons3;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i]+Iaux3.e[i];
+ if ((Iaux2.e[i]>0)&&(Iaux3.e[i]>0))
+ {
+ if (Iaux< 0)
+ Iaux=0x7FFFFFFF;
+ }
+ else if ((Iaux2.e[i]<0)&&(Iaux3.e[i]<0))
+ {
+ if (Iaux> 0)
+ Iaux=0x80000000;
+ }
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_adds [type integer] ===> Error\n");
+ else
+ printf("Function vec_adds [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_adds( UIcons1, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = (unsigned int)(UIaux2.e[i]+UIaux3.e[i]);
+ if ((UIaux< UIaux2.e[i]) || (UIaux< UIaux3.e[i]))
+ UIaux=0xFFFFFFFF;
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_adds [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_adds [type unsigned int] ===> OK\n");
+
+/* Function vec_and */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_and( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ if (Caux1.e[i] != (Caux2.e[i] & Caux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_and [type char] ===> Error\n");
+ else
+ printf("Function vec_and [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_and( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ if (UCaux1.e[i] != (UCaux2.e[i] & UCaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_and [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_and [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_and( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ if (Saux1.e[i] != (Saux2.e[i] & Saux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_and [type short] ===> Error\n");
+ else
+ printf("Function vec_and [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_and( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ if (USaux1.e[i] != (USaux2.e[i] & USaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_and [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_and [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_and( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != (Iaux2.e[i] & Iaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_and [type integer] ===> Error\n");
+ else
+ printf("Function vec_and [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_and( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ if (UIaux1.e[i] != (UIaux2.e[i] & UIaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_and [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_and [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_and( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ Ivec1 = Faux1.i[i];
+ Ivec2 = Faux2.i[i];
+ Ivec3 = Faux3.i[i];
+ if ((Ivec1) != ((Ivec2) & (Ivec3)))
+ err++;
+ }
+ if (err)
+ printf("Function vec_and [type float] ===> Error\n");
+ else
+ printf("Function vec_and [type float] ===> OK\n");
+#endif
+
+/* Function vec_andc */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_andc( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ if (Caux1.e[i] != (Caux2.e[i] & ~Caux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_andc [type char] ===> Error\n");
+ else
+ printf("Function vec_andc [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_andc( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ if (UCaux1.e[i] != (UCaux2.e[i] & ~UCaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_andc [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_andc [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_andc( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ if (Saux1.e[i] != (Saux2.e[i] & ~Saux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_andc [type short] ===> Error\n");
+ else
+ printf("Function vec_andc [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_andc( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ if (USaux1.e[i] != (USaux2.e[i] & ~USaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_andc [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_andc [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_andc( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != (Iaux2.e[i] & ~Iaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_andc [type integer] ===> Error\n");
+ else
+ printf("Function vec_andc [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_andc( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ if (UIaux1.e[i] != (UIaux2.e[i] & ~UIaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_andc [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_andc [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_andc( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ Ivec1 = Faux1.i[i];
+ Ivec2 = Faux2.i[i];
+ Ivec3 = Faux3.i[i];
+ if ((Ivec1) != ((Ivec2) & ~(Ivec3)))
+ err++;
+ }
+ if (err)
+ printf("Function vec_andc [type float] ===> Error\n");
+ else
+ printf("Function vec_andc [type float] ===> OK\n");
+#endif
+
+/* Function vec_avg */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_avg( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ {
+ j = (Caux2.e[i]+Caux3.e[i]+1) >> 1;
+ if (Caux1.e[i] != j)
+ err++;
+ }
+ if (err)
+ printf("Function vec_avg [type char] ===> Error\n");
+ else
+ printf("Function vec_avg [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_avg( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ j = (UCaux2.e[i]+UCaux3.e[i]+1) >> 1;
+ if (UCaux1.e[i] != j)
+ err++;
+ }
+ if (err)
+ printf("Function vec_avg [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_avg [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_avg( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ j = (Saux2.e[i]+Saux3.e[i]+1) >> 1;
+ if (Saux1.e[i] != j)
+ err++;
+ }
+ if (err)
+ printf("Function vec_avg [type short] ===> Error\n");
+ else
+ printf("Function vec_avg [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_avg( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ j = (USaux2.e[i]+USaux3.e[i]+1) >> 1;
+ if (USaux1.e[i] != j)
+ err++;
+ }
+ if (err)
+ printf("Function vec_avg [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_avg [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_avg( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i]%2;
+ if (Iaux2.e[i]<0)
+ Iaux = -Iaux;
+
+ if (Iaux3.e[i]<0)
+ Iaux = (Iaux - Iaux3.e[i]%2 + 1)>>1;
+ else
+ Iaux = (Iaux + Iaux3.e[i]%2 + 1)>>1;
+ Iaux = (Iaux2.e[i] >> 1) + (Iaux3.e[i] >> 1) + Iaux;
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_avg [type integer] ===> Error\n");
+ else
+ printf("Function vec_avg [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_avg( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = (UIaux2.e[i] >> 1) + (UIaux3.e[i] >> 1) +
+ ((UIaux2.e[i]%2 + UIaux3.e[i]%2 + 1 )>>1);
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_avg [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_avg [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+/* Function vec_ceil */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_ceil( Fcons1 );
+ Faux2.v = Fcons1;
+ for( i=0; i< 4; i++ )
+ if (Faux1.e[i] != ceil(Faux2.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_ceil [type float] ===> Error\n");
+ else
+ printf("Function vec_ceil [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_cmpb */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Iaux1.v = vec_cmpb( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ j = 0;
+ if (Faux2.e[i]>Faux3.e[i])
+ j+=(1 << 31);
+ if (Faux2.e[i]<-Faux3.e[i])
+ j+=(1 << 30);
+ if (Iaux1.e[i] != j)
+ err++;
+ }
+
+ if (err)
+ printf("Function vec_cmpb [type float] ===> Error\n");
+ else
+ printf("Function vec_cmpb [type float] ===> OK\n");
+#endif
+
+/* Function vec_cmpeq */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ BCaux1.v = vec_cmpeq( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ {
+ if (Caux2.e[i] == Caux3.e[i])
+ BCaux = 0xFF;
+ else
+ BCaux = 0;
+ if (BCaux1.e[i] != BCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpeq [type char] ===> Error\n");
+ else
+ printf("Function vec_cmpeq [type char] ===> OK\n");
+
+ err = 0;
+ BCaux1.v = vec_cmpeq( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ if (UCaux2.e[i] == UCaux3.e[i])
+ BCaux = 0xFF;
+ else
+ BCaux = 0;
+ if (BCaux1.e[i] != BCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpeq [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_cmpeq [type unsigned char] ===> OK\n");
+
+ err = 0;
+ BSaux1.v = vec_cmpeq( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (Saux2.e[i] == Saux3.e[i])
+ BSaux = 0xFFFF;
+ else
+ BSaux = 0;
+ if (BSaux1.e[i] != BSaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpeq [type short] ===> Error\n");
+ else
+ printf("Function vec_cmpeq [type short] ===> OK\n");
+
+ err = 0;
+ BSaux1.v = vec_cmpeq( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (USaux2.e[i] == USaux3.e[i])
+ BSaux = 0xFFFF;
+ else
+ BSaux = 0;
+ if (BSaux1.e[i] != BSaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpeq [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_cmpeq [type unsigned short] ===> OK\n");
+
+ err = 0;
+ BIaux1.v = vec_cmpeq( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Iaux2.e[i] == Iaux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpeq [type integer] ===> Error\n");
+ else
+ printf("Function vec_cmpeq [type integer] ===> OK\n");
+
+ err = 0;
+ BIaux1.v = vec_cmpeq( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (UIaux2.e[i] == UIaux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpeq [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_cmpeq [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ BIaux1.v = vec_cmpeq( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Faux2.e[i] == Faux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpeq [type float] ===> Error\n");
+ else
+ printf("Function vec_cmpeq [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_cmpge */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ BIaux1.v = vec_cmpge( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Faux2.e[i] >= Faux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpge [type float] ===> Error\n");
+ else
+ printf("Function vec_cmpge [type float] ===> OK\n");
+#endif
+
+/* Function vec_cmpgt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ BCaux1.v = vec_cmpgt( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ {
+ if (Caux2.e[i] > Caux3.e[i])
+ BCaux = 0xFF;
+ else
+ BCaux = 0;
+ if (BCaux1.e[i] != BCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpgt [type char] ===> Error\n");
+ else
+ printf("Function vec_cmpgt [type char] ===> OK\n");
+
+ err = 0;
+ BCaux1.v = vec_cmpgt( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ if (UCaux2.e[i] > UCaux3.e[i])
+ BCaux = 0xFF;
+ else
+ BCaux = 0;
+ if (BCaux1.e[i] != BCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpgt [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_cmpgt [type unsigned char] ===> OK\n");
+
+ err = 0;
+ BSaux1.v = vec_cmpgt( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (Saux2.e[i] > Saux3.e[i])
+ BSaux = 0xFFFF;
+ else
+ BSaux = 0;
+ if (BSaux1.e[i] != BSaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpgt [type short] ===> Error\n");
+ else
+ printf("Function vec_cmpgt [type short] ===> OK\n");
+
+ err = 0;
+ BSaux1.v = vec_cmpgt( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (USaux2.e[i] > USaux3.e[i])
+ BSaux = 0xFFFF;
+ else
+ BSaux = 0;
+ if (BSaux1.e[i] != BSaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpgt [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_cmpgt [type unsigned short] ===> OK\n");
+
+ err = 0;
+ BIaux1.v = vec_cmpgt( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Iaux2.e[i] > Iaux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpgt [type integer] ===> Error\n");
+ else
+ printf("Function vec_cmpgt [type integer] ===> OK\n");
+
+ err = 0;
+ BIaux1.v = vec_cmpgt( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (UIaux2.e[i] > UIaux3.e[i])
+ BIaux=0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpgt [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_cmpgt [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ BIaux1.v = vec_cmpgt( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Faux2.e[i] > Faux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmpgt [type float] ===> Error\n");
+ else
+ printf("Function vec_cmpgt [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_cmple */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ BIaux1.v = vec_cmple( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Faux2.e[i] <= Faux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmple [type float] ===> Error\n");
+ else
+ printf("Function vec_cmple [type float] ===> OK\n");
+#endif
+
+/* Function vec_cmplt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ BCaux1.v = vec_cmplt( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ {
+ if (Caux2.e[i] < Caux3.e[i])
+ BCaux = 0xFF;
+ else
+ BCaux = 0;
+ if (BCaux1.e[i] != BCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmplt [type char] ===> Error\n");
+ else
+ printf("Function vec_cmplt [type char] ===> OK\n");
+
+ err = 0;
+ BCaux1.v = vec_cmplt( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ if (UCaux2.e[i] < UCaux3.e[i])
+ BCaux = 0xFF;
+ else
+ BCaux = 0;
+ if (BCaux1.e[i] != BCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmplt [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_cmplt [type unsigned char] ===> OK\n");
+
+ err = 0;
+ BSaux1.v = vec_cmplt( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (Saux2.e[i] < Saux3.e[i])
+ BSaux = 0xFFFF;
+ else
+ BSaux = 0;
+ if (BSaux1.e[i] != BSaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmplt [type short] ===> Error\n");
+ else
+ printf("Function vec_cmplt [type short] ===> OK\n");
+
+ err = 0;
+ BSaux1.v = vec_cmplt( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (USaux2.e[i] < USaux3.e[i])
+ BSaux = 0xFFFF;
+ else
+ BSaux = 0;
+ if (BSaux1.e[i] != BSaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmplt [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_cmplt [type unsigned short] ===> OK\n");
+
+ err = 0;
+ BIaux1.v = vec_cmplt( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Iaux2.e[i] < Iaux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmplt [type integer] ===> Error\n");
+ else
+ printf("Function vec_cmplt [type integer] ===> OK\n");
+
+ err = 0;
+ BIaux1.v = vec_cmplt( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (UIaux2.e[i] < UIaux3.e[i])
+ BIaux=0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmplt [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_cmplt [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ BIaux1.v = vec_cmplt( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Faux2.e[i] < Faux3.e[i])
+ BIaux = 0xFFFFFFFF;
+ else
+ BIaux = 0;
+ if (BIaux1.e[i] != BIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_cmplt [type float] ===> Error\n");
+ else
+ printf("Function vec_cmplt [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_ctf */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ b = 2;
+ Faux1.v = vec_ctf( Icons1, 2 );
+ Iaux1.v = Icons1;
+ for( i=0; i< 4; i++ )
+ if (Faux1.e[i] != (((float)Iaux1.e[i])/(1<<b)))
+ err++;
+ if (err)
+ printf("Function vec_ctf [type integer] ===> Error\n");
+ else
+ printf("Function vec_ctf [type integer] ===> OK\n");
+
+ err = 0;
+ b = 2;
+ Faux1.v = vec_ctf( UIcons1, 2 );
+ UIaux1.v = UIcons1;
+ for( i=0; i< 4; i++ )
+ if (Faux1.e[i] != (((float)UIaux1.e[i])/(1<<b)))
+ err++;
+ if (err)
+ printf("Function vec_ctf [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_ctf [type unsigned int] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_cts */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ b = 2;
+ Iaux1.v = vec_cts( Fcons3, 2 );
+ Faux1.v = Fcons3;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != (int)(Faux1.e[i]*(1<<b)))
+ err++;
+ if (err)
+ printf("Function vec_cts [type float] ===> Error\n");
+ else
+ printf("Function vec_cts [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_ctu */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ b = 2;
+ UIaux1.v = vec_ctu( Fcons3, 2 );
+ Faux1.v = Fcons3;
+ for( i=0; i< 4; i++ )
+ {
+ double d = Faux1.e[i]*(1<<b);
+ if (d > 0xffffffff)
+ d = 0xffffffff;
+ if (d < 0)
+ d = 0;
+ if (UIaux1.e[i] != (unsigned int)(d))
+ err++;
+ }
+ if (err)
+ printf("Function vec_ctu [type float] ===> Error\n");
+ else
+ printf("Function vec_ctu [type float] ===> OK\n");
+#endif
+
+ part1();
+
+ part2();
+
+ part3();
+
+ part4();
+
+ part5();
+
+ return 0;
+}
+
+
+
+
+int part1()
+{
+ TvecChar Caux1;//, Caux2, Caux3, Caux4;
+ TvecUChar UCaux1;//, UCaux2, UCaux3, UCaux4;
+ TvecShort Saux1;//, Saux2, Saux3, Saux4;
+ TvecUShort USaux1;//, USaux2, USaux3, USaux4;
+ TvecInt Iaux1;//, Iaux2, Iaux3, Iaux4;
+ TvecUInt UIaux1;//, UIaux2, UIaux3, UIaux4;
+#if defined TEST_FLOATS
+ TvecFloat Faux1, Faux2;//, Faux3, Faux4;
+#endif
+
+ int i, err, j;//, b, bAux;
+// signed int Ivec1, Ivec2, Ivec3;
+// signed short *Svec1;
+// unsigned int *UIvec1;
+// unsigned short *USvec1;
+// unsigned char *UCvec1;
+#if defined TEST_FLOATS
+// float *Fvec1;
+#endif
+
+ /* For saturated rutines */
+// long long int LLaux;
+
+#if defined TEST_FLOATS
+ float Faux;
+#endif
+ signed int Iaux;//, I1, I2;
+// unsigned int UIaux, UI1, UI2;
+// signed short Saux;
+// unsigned short USaux;
+// signed char Caux;
+// unsigned char UCaux;
+
+/*
+ union
+ {
+ float f;
+ signed int si;
+ unsigned int ui;
+ signed short ss[2];
+ unsigned short us[2];
+ signed char sc[4];
+ unsigned char uc[4];
+ } INTunion1, INTunion2;
+
+ union
+ {
+ signed short ss;
+ unsigned short us;
+ signed char sc[2];
+ unsigned char uc[2];
+ } SHOunion1, SHOunion2;
+*/
+
+#if defined (GCC_COMPILER)
+ vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+// vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+// vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127};
+ vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7};
+// vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+// vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
+ vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3};
+// vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000};
+// vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767};
+// vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3};
+// vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1};
+ vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4};
+ vector signed int Icons1 = (vector signed int){-4, -1, 1, 4};
+// vector signed int Icons2 = (vector signed int){1, 1, 1, 1};
+// vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF};
+ vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1};
+// vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1};
+// vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2};
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999};
+// vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0};
+ vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0};
+#endif
+
+#elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+ vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127);
+ vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
+ vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+ vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3);
+ vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000);
+ vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767);
+ vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3);
+ vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1);
+ vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4);
+ vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4);
+ vector signed int Icons2 = (vector signed int)(1, 1, 1, 1);
+ vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF);
+ vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1);
+ vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1);
+ vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2);
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999);
+ vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0);
+ vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0);
+#endif
+
+#endif
+
+
+/* Variables to be allocated with calloc_vec (16 bytes aligned) */
+ unsigned char *UCmem = (unsigned char*)calloc_vec( 1, sizeof(vector unsigned char) );
+ signed char *Cmem = (signed char*)calloc_vec( 1, sizeof(vector signed char) );
+ unsigned short *USmem = (unsigned short*)calloc_vec( 1, sizeof(vector unsigned short) );
+ signed short *Smem = (signed short*)calloc_vec( 1, sizeof(vector signed short) );
+ unsigned int *UImem = (unsigned int*)calloc_vec( 1, sizeof(vector unsigned int) );
+ signed int *Imem = (signed int*)calloc_vec( 1, sizeof(vector signed int) );
+#if defined TEST_FLOATS
+ float *Fmem = (float*)calloc_vec( 1, sizeof(vector float) );
+#endif
+
+/* Function vec_dss */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_dss [Vector data Stream Stop] not checked\n");
+
+/* Function vec_dssall */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_dssall [Vector Stream Stop all] not checked\n");
+
+/* Function vec_dst */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_dst [Vector Data Stream Touch] not checked\n");
+
+/* Function vec_dstst */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_dstst [Vector Data Stream Touch for Store] not checked\n");
+
+/* Function vec_dststt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_dststt [Vector Data Stream Touch for Store Transient] not checked\n");
+
+/* Function vec_dstt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_dstt [Vector Data Stream Touch Transient] not checked\n");
+
+#if defined TEST_FLOATS
+/* Function vec_expte */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_expte( Fcons1 );
+ Faux2.v = Fcons1;
+ for( i=0; i< 4; i++ )
+ {
+ Faux = pow(2,Faux2.e[i]);
+/*
+ Ivec1 = (signed int*)(&Faux1.e[i]);
+ Ivec2 = (signed int*)(&Faux);
+ *Ivec1 = (*Ivec1) & 0xFFF00000;
+ *Ivec2 = (*Ivec2) & 0xFFF00000;
+ if (Faux1.e[i] != Faux)
+ err++;
+*/
+ Faux = (Faux - Faux1.e[i])/Faux;
+ if (Faux>0.1)
+ err++;
+ }
+ if (err)
+ printf("Function vec_expte [type float] ===> Error\n");
+ else
+ printf("Function vec_expte [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_floor */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_floor( Fcons1 );
+ Faux2.v = Fcons1;
+ for( i=0; i< 4; i++ )
+ if (Faux1.e[i] != floor(Faux2.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_floor [type float] ===> Error\n");
+ else
+ printf("Function vec_floor [type float] ===> OK\n");
+#endif
+
+/* Function vec_ld */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ memcpy( UCmem, &UCcons1, sizeof(vector unsigned char) );
+ UCaux1.v = vec_ld( 0, UCmem );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]==UCmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ld [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_ld [type unsigned char] ===> OK\n");
+
+ err = 0;
+ memcpy( Cmem, &Ccons1, sizeof(vector signed char) );
+ Caux1.v = vec_ld( 0, Cmem );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]==Cmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ld [type char] ===> Error\n");
+ else
+ printf("Function vec_ld [type char] ===> OK\n");
+
+ err = 0;
+ memcpy( USmem, &UScons3, sizeof(vector unsigned short) );
+ USaux1.v = vec_ld( 0, USmem );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]==USmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ld [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_ld [type unsigned short] ===> OK\n");
+
+ err = 0;
+ memcpy( Smem, &Scons1, sizeof(vector signed short) );
+ Saux1.v = vec_ld( 0, Smem );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]==Smem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ld [type short] ===> Error\n");
+ else
+ printf("Function vec_ld [type short] ===> OK\n");
+
+ err = 0;
+ memcpy( UImem, &UIcons1, sizeof(vector unsigned int) );
+ UIaux1.v = vec_ld( 0, UImem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]==UImem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ld [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_ld [type unsigned int] ===> OK\n");
+
+ err = 0;
+ memcpy( Imem, &Icons1, sizeof(vector signed int) );
+ Iaux1.v = vec_ld( 0, Imem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]==Imem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ld [type int] ===> Error\n");
+ else
+ printf("Function vec_ld [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ memcpy( Fmem, &Fcons1, sizeof(vector float) );
+ Faux1.v = vec_ld( 0, Fmem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]==Fmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ld [type float] ===> Error\n");
+ else
+ printf("Function vec_ld [type float] ===> OK\n");
+#endif
+
+/* Function vec_lde */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+
+ err = 0;
+ for (i= 0; i< 16; i++)
+ UCmem[i] = (unsigned char)i;
+ j = 1;
+ i = j*sizeof(unsigned char);
+ UCaux1.v = vec_lde( i, UCmem );
+
+ if (UCaux1.e[j] != UCmem[j]) err++;
+
+ if (err)
+ printf("Function vec_lde [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_lde [type unsigned char] ===> OK\n");
+
+ err = 0;
+ for (i= 0; i< 16; i++)
+ Cmem[i] = (char)(-i);
+ j = 1;
+ i = j*sizeof(char);
+ Caux1.v = vec_lde( i, Cmem );
+
+ if (Caux1.e[j] != Cmem[j]) err++;
+
+ if (err)
+ printf("Function vec_lde [type char] ===> Error\n");
+ else
+ printf("Function vec_lde [type char] ===> OK\n");
+
+ err = 0;
+ for (i= 0; i< 8; i++)
+ USmem[i] = (unsigned short)(i);
+ j = 1;
+ i = j*sizeof(unsigned short);
+ USaux1.v = vec_lde( i, USmem );
+
+ if (USaux1.e[j] != USmem[j]) err++;
+
+ if (err)
+ printf("Function vec_lde [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_lde [type unsigned short] ===> OK\n");
+
+ err = 0;
+ for (i= 0; i< 8; i++)
+ Smem[i] = (short)(-i);
+ j = 1;
+ i = j*sizeof(short);
+ Saux1.v = vec_lde( i, Smem );
+
+ if (Saux1.e[j] != Smem[j]) err++;
+
+ if (err)
+ printf("Function vec_lde [type short] ===> Error\n");
+ else
+ printf("Function vec_lde [type short] ===> OK\n");
+
+ err = 0;
+ for (i= 0; i< 4; i++)
+ UImem[i] = (unsigned int)(i);
+ j = 1;
+ i = j*sizeof(unsigned int);
+ UIaux1.v = vec_lde( i, UImem );
+
+ if (UIaux1.e[j] != UImem[j]) err++;
+
+ if (err)
+ printf("Function vec_lde [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_lde [type unsigned int] ===> OK\n");
+
+ err = 0;
+ for (i= 0; i< 4; i++)
+ Imem[i] = (int)(-i);
+ j = 1;
+ i = j*sizeof(int);
+ Iaux1.v = vec_lde( i, Imem );
+
+ if (Iaux1.e[j] != Imem[j]) err++;
+
+ if (err)
+ printf("Function vec_lde [type int] ===> Error\n");
+ else
+ printf("Function vec_lde [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ for (i= 0; i< 4; i++)
+ Fmem[i] = ((float)(-i)) - 0.5;
+ j = 1;
+ i = j*sizeof(float);
+ Faux1.v = vec_lde( i, Fmem );
+
+ if (Faux1.e[j] != Fmem[j]) err++;
+
+ if (err)
+ printf("Function vec_lde [type float] ===> Error\n");
+ else
+ printf("Function vec_lde [type float] ===> OK\n");
+#endif
+
+#if 0
+/* Function vec_ldl */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ memcpy( UCmem, &UCcons1, sizeof(vector unsigned char) );
+ UCaux1.v = vec_ldl( 0, UCmem );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]==UCmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ldl [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_ldl [type unsigned char] ===> OK\n");
+
+ err = 0;
+ memcpy( Cmem, &Ccons1, sizeof(vector signed char) );
+ Caux1.v = vec_ldl( 0, Cmem );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]==Cmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ldl [type char] ===> Error\n");
+ else
+ printf("Function vec_ldl [type char] ===> OK\n");
+
+ err = 0;
+ memcpy( USmem, &UScons3, sizeof(vector unsigned short) );
+ USaux1.v = vec_ldl( 0, USmem );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]==USmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ldl [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_ldl [type unsigned short] ===> OK\n");
+
+ err = 0;
+ memcpy( Smem, &Scons1, sizeof(vector signed short) );
+ Saux1.v = vec_ldl( 0, Smem );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]==Smem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ldl [type short] ===> Error\n");
+ else
+ printf("Function vec_ldl [type short] ===> OK\n");
+
+ err = 0;
+ memcpy( UImem, &UIcons1, sizeof(vector unsigned int) );
+ UIaux1.v = vec_ldl( 0, UImem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]==UImem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ldl [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_ldl [type unsigned int] ===> OK\n");
+
+ err = 0;
+ memcpy( Imem, &Icons1, sizeof(vector signed int) );
+ Iaux1.v = vec_ldl( 0, Imem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]==Imem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ldl [type int] ===> Error\n");
+ else
+ printf("Function vec_ldl [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ memcpy( Fmem, &Fcons1, sizeof(vector float) );
+ Faux1.v = vec_ldl( 0, Fmem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]==Fmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_ldl [type float] ===> Error\n");
+ else
+ printf("Function vec_ldl [type float] ===> OK\n");
+#endif
+#endif // #if 0
+
+ /* Free dynamic vector variables */
+ free_vec( UCmem );
+ free_vec( Cmem );
+ free_vec( USmem );
+ free_vec( Smem );
+ free_vec( UImem );
+ free_vec( Imem );
+#if defined TEST_FLOATS
+ free_vec( Fmem );
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_loge */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_loge( Fcons3 );
+ Faux2.v = Fcons3;
+ for( i=0; i< 4; i++ )
+ {
+ Faux = log2(Faux2.e[i]);
+ if (Faux!=0.0)
+ Faux = (Faux - Faux1.e[i])/Faux;
+ else
+ Faux = Faux - Faux1.e[i];
+ if (Faux>0.1)
+ err++;
+ }
+ if (err)
+ printf("Function vec_loge [type float] ===> Error\n");
+ else
+ printf("Function vec_loge [type float] ===> OK\n");
+#endif
+
+ return 0;
+}
+
+
+
+
+int part2()
+{
+ TvecChar Caux1, Caux2, Caux3;//, Caux4;
+ TvecUChar UCaux1, UCaux2, UCaux3;//, UCaux4;
+ TvecShort Saux1, Saux2, Saux3, Saux4;
+ TvecUShort USaux1, USaux2, USaux3, USaux4;
+ TvecInt Iaux1, Iaux2, Iaux3;//, Iaux4;
+ TvecUInt UIaux1, UIaux2, UIaux3;//, UIaux4;
+#if defined TEST_FLOATS
+ TvecFloat Faux1, Faux2, Faux3, Faux4;
+#endif
+
+ int i, err, j, b, bAux;
+#if defined TEST_FLOATS
+ signed int Ivec1, Ivec2, Ivec3;
+#endif
+// signed short *Svec1;
+// unsigned int *UIvec1;
+// unsigned short *USvec1;
+// unsigned char *UCvec1;
+#if defined TEST_FLOATS
+// float *Fvec1;
+#endif
+
+ /* For saturated rutines */
+// long long int LLaux;
+
+#if defined TEST_FLOATS
+ float Faux;
+#endif
+ signed int Iaux, I1, I2;
+ unsigned int UIaux, UI1, UI2;
+ signed short Saux;
+ unsigned short USaux;
+ signed char Caux;
+ unsigned char UCaux;
+
+ union
+ {
+ float f;
+ signed int si;
+ unsigned int ui;
+ signed short ss[2];
+ unsigned short us[2];
+ signed char sc[4];
+ unsigned char uc[4];
+ } INTunion1;//, INTunion2;
+
+/*
+ union
+ {
+ signed short ss;
+ unsigned short us;
+ signed char sc[2];
+ unsigned char uc[2];
+ } SHOunion1, SHOunion2;
+*/
+
+#if defined (GCC_COMPILER)
+ vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+// vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127};
+ vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+// vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
+ vector signed short Scons1 = (vector signed short){256, 320, 340, -1, 0, 1, 2, 3};
+ vector signed short Scons2 = (vector signed short){256, 320, 340, 1, 1, 1, -10000, -10000};
+ vector signed short Scons3 = (vector signed short){256, 320, 340, 32767, -32768, 32767, -32768, 32767};
+ vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3};
+ vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1};
+ vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4};
+ vector signed int Icons1 = (vector signed int){-4, -1, 1, 4};
+ vector signed int Icons2 = (vector signed int){1, 1, 1, 1};
+ vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF};
+ vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1};
+ vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1};
+ vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2};
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999};
+ vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0};
+ vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0};
+#endif
+
+#elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+ vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127);
+ vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
+// vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+ vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3);
+ vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000);
+ vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767);
+ vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3);
+ vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1);
+ vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4);
+ vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4);
+ vector signed int Icons2 = (vector signed int)(1, 1, 1, 1);
+ vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF);
+ vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1);
+ vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1);
+ vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2);
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999);
+ vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0);
+ vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0);
+#endif
+
+#endif
+
+
+/* Function vec_lvsl */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ b = 3;
+ UCaux1.v = vec_lvsl( b, &b);
+ bAux = b + (size_t)(&b);
+ b = bAux & 0xF;
+# if defined(GCC_COMPILER)
+ UCaux2.v =(vector unsigned char){0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF};
+# elif defined(MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v =(vector unsigned char)(0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF);
+# endif
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux2.e[i]+b;
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_lvsl [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_lvsl [type unsigned char] ===> OK\n");
+
+/* Function vec_lvsr */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ b = 3;
+ UCaux1.v = vec_lvsr( b, &b);
+ bAux = b + (size_t)(&b);
+ b = bAux & 0xF;
+# if defined (GCC_COMPILER)
+ UCaux2.v =(vector unsigned char){0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v =(vector unsigned char)(0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F);
+# endif
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux2.e[i]-b;
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_lvsr [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_lvsr [type unsigned char] ===> OK\n");
+
+#if defined TEST_FLOATS
+/* Function vec_madd */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_madd( Fcons1, Fcons2, Fcons3 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ Faux4.v = Fcons3;
+ for( i=0; i< 4; i++ )
+ if (Faux1.e[i] != (Faux2.e[i]*Faux3.e[i]+Faux4.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_madd [type float] ===> Error\n");
+ else
+ printf("Function vec_madd [type float] ===> OK\n");
+#endif
+
+/* Function vec_madds */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Saux1.v = vec_madds( Scons1, Scons3, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons3;
+ Saux4.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ INTunion1.si = Saux2.e[i]*Saux3.e[i];
+ INTunion1.si = INTunion1.si >> 15;
+ INTunion1.si = INTunion1.si + Saux4.e[i];
+ if (INTunion1.si>32767)
+ Saux=0x7FFF;
+ else if (INTunion1.si<(-32768))
+ Saux=0x8000;
+ else
+ Saux= INTunion1.ss[1];
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_madds [type short] ===> Error\n");
+ else
+ printf("Function vec_madds [type short] ===> OK\n");
+
+/* Function vec_max */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_max( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ {
+ if (Caux2.e[i]>Caux3.e[i])
+ Caux = Caux2.e[i];
+ else
+ Caux = Caux3.e[i];
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_max [type char] ===> Error\n");
+ else
+ printf("Function vec_max [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_max( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ if (UCaux2.e[i]>UCaux3.e[i])
+ UCaux = UCaux2.e[i];
+ else
+ UCaux = UCaux3.e[i];
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_max [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_max [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_max( Scons1, Scons3 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons3;
+ for( i=0; i< 8; i++ )
+ {
+ if (Saux2.e[i]>Saux3.e[i])
+ Saux = Saux2.e[i];
+ else
+ Saux = Saux3.e[i];
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_max [type short] ===> Error\n");
+ else
+ printf("Function vec_max [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_max( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (USaux2.e[i]>USaux3.e[i])
+ USaux = USaux2.e[i];
+ else
+ USaux = USaux3.e[i];
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_max [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_max [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_max( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Iaux2.e[i]>Iaux3.e[i])
+ Iaux = Iaux2.e[i];
+ else
+ Iaux = Iaux3.e[i];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_max [type integer] ===> Error\n");
+ else
+ printf("Function vec_max [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_max( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (UIaux2.e[i]>UIaux3.e[i])
+ UIaux = UIaux2.e[i];
+ else
+ UIaux = UIaux3.e[i];
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_max [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_max [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_max( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Faux2.e[i]>Faux3.e[i])
+ Faux = Faux2.e[i];
+ else
+ Faux = Faux3.e[i];
+ if (Faux1.e[i] != Faux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_max [type float] ===> Error\n");
+ else
+ printf("Function vec_max [type float] ===> OK\n");
+#endif
+
+/* Function vec_mergeh */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_mergeh( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 8; i++ )
+ if ((Caux1.e[2*i] != Caux2.e[i])||(Caux1.e[2*i+1]!=Caux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_mergeh [type char] ===> Error\n");
+ else
+ printf("Function vec_mergeh [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_mergeh( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 8; i++ )
+ if ((UCaux1.e[2*i] != UCaux2.e[i])||(UCaux1.e[2*i+1]!=UCaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_mergeh [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_mergeh [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_mergeh( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 4; i++ )
+ if ((Saux1.e[2*i] != Saux2.e[i])||(Saux1.e[2*i+1]!=Saux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_mergeh [type short] ===> Error\n");
+ else
+ printf("Function vec_mergeh [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_mergeh( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 4; i++ )
+ if ((USaux1.e[2*i] != USaux2.e[i])||(USaux1.e[2*i+1]!=USaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_mergeh [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_mergeh [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_mergeh( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 2; i++ )
+ if ((Iaux1.e[2*i] != Iaux2.e[i])||(Iaux1.e[2*i+1]!=Iaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_mergeh [type integer] ===> Error\n");
+ else
+ printf("Function vec_mergeh [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_mergeh( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 2; i++ )
+ if ((UIaux1.e[2*i] != UIaux2.e[i])||(UIaux1.e[2*i+1]!=UIaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_mergeh [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_mergeh [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_mergeh( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 2; i++ )
+ if ((Faux1.e[2*i] != Faux2.e[i])||(Faux1.e[2*i+1]!=Faux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_mergeh [type float] ===> Error\n");
+ else
+ printf("Function vec_mergeh [type float] ===> OK\n");
+#endif
+
+/* Function vec_mergel */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_mergel( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 8; i++ )
+ if ((Caux1.e[2*i] != Caux2.e[i+8])||(Caux1.e[2*i+1]!=Caux3.e[i+8]))
+ err++;
+ if (err)
+ printf("Function vec_mergel [type char] ===> Error\n");
+ else
+ printf("Function vec_mergel [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_mergel( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 8; i++ )
+ if ((UCaux1.e[2*i] != UCaux2.e[i+8])||(UCaux1.e[2*i+1]!=UCaux3.e[i+8]))
+ err++;
+ if (err)
+ printf("Function vec_mergel [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_mergel [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_mergel( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 4; i++ )
+ if ((Saux1.e[2*i] != Saux2.e[i+4])||(Saux1.e[2*i+1]!=Saux3.e[i+4]))
+ err++;
+ if (err)
+ printf("Function vec_mergel [type short] ===> Error\n");
+ else
+ printf("Function vec_mergel [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_mergel( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 4; i++ )
+ if ((USaux1.e[2*i] != USaux2.e[i+4])||(USaux1.e[2*i+1]!=USaux3.e[i+4]))
+ err++;
+ if (err)
+ printf("Function vec_mergel [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_mergel [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_mergel( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 2; i++ )
+ if ((Iaux1.e[2*i] != Iaux2.e[i+2])||(Iaux1.e[2*i+1]!=Iaux3.e[i+2]))
+ err++;
+ if (err)
+ printf("Function vec_mergel [type integer] ===> Error\n");
+ else
+ printf("Function vec_mergel [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_mergel( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 2; i++ )
+ if ((UIaux1.e[2*i] != UIaux2.e[i+2])||(UIaux1.e[2*i+1]!=UIaux3.e[i+2]))
+ err++;
+ if (err)
+ printf("Function vec_mergel [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_mergel [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_mergel( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 2; i++ )
+ if ((Faux1.e[2*i] != Faux2.e[i+2])||(Faux1.e[2*i+1]!=Faux3.e[i+2]))
+ err++;
+ if (err)
+ printf("Function vec_mergel [type float] ===> Error\n");
+ else
+ printf("Function vec_mergel [type float] ===> OK\n");
+#endif
+
+/* Function vec_mfvscr */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_mfvscr [Vector Move from Vector Status and Control Register] not checked\n");
+
+/* Function vec_min */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+#ifndef XLC_COMPILER
+ err = 0;
+ Caux1.v = vec_min( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (Caux2.e[i]<Caux3.e[i])
+ Caux = Caux2.e[i];
+ else
+ Caux = Caux3.e[i];
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_min [type char] ===> Error\n");
+ else
+ printf("Function vec_min [type char] ===> OK\n");
+#endif
+
+ err = 0;
+ UCaux1.v = vec_min( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (UCaux2.e[i]<UCaux3.e[i])
+ UCaux = UCaux2.e[i];
+ else
+ UCaux = UCaux3.e[i];
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_min [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_min [type unsigned char] ===> OK\n");
+
+#ifndef XLC_COMPILER
+ err = 0;
+ Saux1.v = vec_min( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (Saux2.e[i]<Saux3.e[i])
+ Saux = Saux2.e[i];
+ else
+ Saux = Saux3.e[i];
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_min [type short] ===> Error\n");
+ else
+ printf("Function vec_min [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_min( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (USaux2.e[i]<USaux3.e[i])
+ USaux = USaux2.e[i];
+ else
+ USaux = USaux3.e[i];
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_min [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_min [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_min( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Iaux2.e[i]<Iaux3.e[i])
+ Iaux = Iaux2.e[i];
+ else
+ Iaux = Iaux3.e[i];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_min [type integer] ===> Error\n");
+ else
+ printf("Function vec_min [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_min( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (UIaux2.e[i]<UIaux3.e[i])
+ UIaux = UIaux2.e[i];
+ else
+ UIaux = UIaux3.e[i];
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_min [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_min [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_min( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Faux2.e[i]<Faux3.e[i])
+ Faux = Faux2.e[i];
+ else
+ Faux = Faux3.e[i];
+ if (Faux1.e[i] != Faux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_min [type float] ===> Error\n");
+ else
+ printf("Function vec_min [type float] ===> OK\n");
+#endif
+
+#endif
+
+/* Function vec_mladd */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+#ifndef XLC_COMPILER
+ err = 0;
+ Saux1.v = vec_mladd( Scons1, Scons2, Scons3 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ Saux4.v = Scons3;
+ for( i=0; i< 8; i++ )
+ {
+ INTunion1.si = Saux2.e[i]*Saux3.e[i];
+ INTunion1.si = INTunion1.si + Saux4.e[i];
+ if (Saux1.e[i] != INTunion1.ss[1])
+ err++;
+ }
+ if (err)
+ printf("Function vec_mladd [type short] ===> Error\n");
+ else
+ printf("Function vec_mladd [type short] ===> OK\n");
+#endif
+
+ err = 0;
+ USaux1.v = vec_mladd( UScons1, UScons2, UScons3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ USaux4.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ INTunion1.ui = USaux2.e[i]*USaux3.e[i];
+ INTunion1.ui = INTunion1.ui + USaux4.e[i];
+ if (USaux1.e[i] != INTunion1.us[1])
+ err++;
+ }
+ if (err)
+ printf("Function vec_mladd [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_mladd [type unsigned short] ===> OK\n");
+
+/* Function vec_mradds */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Saux1.v = vec_mradds( Scons1, Scons2, Scons3 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ Saux4.v = Scons3;
+ for( i=0; i< 8; i++ )
+ {
+ INTunion1.si = Saux2.e[i]*Saux3.e[i]+0x4000;
+ INTunion1.si = INTunion1.si >> 15;
+ INTunion1.si = INTunion1.si + Saux4.e[i];
+ if (INTunion1.si>32767)
+ Saux = 0x7FFF;
+ else if (INTunion1.si<(-32768))
+ Saux = 0x8000;
+ else
+ Saux = INTunion1.ss[1];
+ if (Saux1.e[i] != Saux)
+ err++;
+
+printf("vector: %d \n", Saux1.e[i]);
+printf("scalar: %d \n", Saux);
+ }
+
+ if (err)
+ printf("Function vec_mradds [type short] ===> Error\n");
+ else
+ printf("Function vec_mradds [type short] ===> OK\n");
+
+/* Function vec_msum */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+#ifndef XLC_COMPILER
+ err = 0;
+ Iaux1.v = vec_msum( Ccons1, UCcons2, Icons1 );
+ Caux1.v = Ccons1;
+ UCaux1.v = UCcons2;
+ Iaux2.v = Icons1;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i];
+ for (j=0; j< 4; j++)
+ Iaux = Iaux + Caux1.e[4*i+j]*UCaux1.e[4*i+j];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_msum [type char] ===> Error\n");
+ else
+ printf("Function vec_msum [type char] ===> OK\n");
+#endif
+
+ err = 0;
+ UIaux1.v = vec_msum( UCcons1, UCcons2, UIcons1 );
+ UCaux1.v = UCcons1;
+ UCaux2.v = UCcons2;
+ UIaux2.v = UIcons1;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = UIaux2.e[i];
+ for (j=0; j< 4; j++)
+ UIaux = UIaux + UCaux1.e[4*i+j]*UCaux2.e[4*i+j];
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_msum [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_msum [type unsigned char] ===> OK\n");
+
+#ifndef XLC_COMPILER
+ err = 0;
+ Iaux1.v = vec_msum( Scons1, Scons2, Icons1 );
+ Saux1.v = Scons1;
+ Saux2.v = Scons2;
+ Iaux2.v = Icons1;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i];
+ for (j=0; j< 2; j++)
+ Iaux = Iaux + Saux1.e[2*i+j]*Saux2.e[2*i+j];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_msum [type short] ===> Error\n");
+ else
+ printf("Function vec_msum [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_msum( UScons1, UScons2, UIcons1 );
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ UIaux2.v = UIcons1;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = UIaux2.e[i];
+ for (j=0; j< 2; j++)
+ UIaux = UIaux + USaux1.e[2*i+j]*USaux2.e[2*i+j];
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_msum [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_msum [type unsigned short] ===> OK\n");
+#endif
+
+/* Function vec_msums */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Iaux1.v = vec_msums( Scons2, Scons3, Icons3 );
+ Saux1.v = Scons2;
+ Saux2.v = Scons3;
+ Iaux2.v = Icons3;
+ for( i=0; i< 4; i++ )
+ {
+ I1 = Saux1.e[2*i]*Saux2.e[2*i];
+ I2 = Saux1.e[2*i+1]*Saux2.e[2*i+1];
+ Iaux = I1 + I2;
+ if ((I1>0)&&(I2>0)&&(Iaux<0))
+ Iaux=0x7FFFFFFF;
+ else if ((I1<0)&&(I2<0)&&(Iaux>0))
+ Iaux=0x80000000;
+ I1 = Iaux2.e[i];
+ I2 = Iaux;
+ Iaux = I1 + I2;
+ if ((I1>0)&&(I2>0)&&(Iaux<0))
+ Iaux=0x7FFFFFFF;
+ else if ((I1<0)&&(I2<0)&&(Iaux>0))
+ Iaux=0x80000000;
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_msums [type short] ===> Error\n");
+ else
+ printf("Function vec_msums [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_msums( UScons2, UScons3, UIcons3 );
+ USaux1.v = UScons2;
+ USaux2.v = UScons3;
+ UIaux2.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ UI1 = USaux1.e[2*i]*USaux2.e[2*i];
+ UI2 = USaux1.e[2*i+1]*USaux2.e[2*i+1];
+ UIaux = UI1 + UI2;
+ if ((UIaux<UI1)||(UIaux<UI2))
+ UIaux=0xFFFFFFFF;
+ UI1 = UIaux2.e[i];
+ UI2 = UIaux;
+ UIaux = UI1 + UI2;
+ if ((UIaux<UI1)||(UIaux<UI2))
+ UIaux=0xFFFFFFFF;
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_msums [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_msums [type unsigned short] ===> OK\n");
+
+/* Function vec_mtvscr */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_mtvscr [Vector Move to Vector Status and Control Register] not checked\n");
+
+/* Function vec_mule */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Saux1.v = vec_mule( Ccons1, Ccons2 );
+ Caux1.v = Ccons1;
+ Caux2.v = Ccons2;
+ for( i=0; i< 4; i++ )
+ if (Saux1.e[i] != (Caux1.e[2*i]*Caux2.e[2*i]))
+ err++;
+ if (err)
+ printf("Function vec_mule [type char] ===> Error\n");
+ else
+ printf("Function vec_mule [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_mule( UCcons1, UCcons2 );
+ UCaux1.v = UCcons1;
+ UCaux2.v = UCcons2;
+ for( i=0; i< 4; i++ )
+ if (USaux1.e[i] != (UCaux1.e[2*i]*UCaux2.e[2*i]))
+ err++;
+ if (err)
+ printf("Function vec_mule [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_mule [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_mule( Scons1, Scons2 );
+ Saux1.v = Scons1;
+ Saux2.v = Scons2;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != (Saux1.e[2*i]*Saux2.e[2*i]))
+ err++;
+ if (err)
+ printf("Function vec_mule [type short] ===> Error\n");
+ else
+ printf("Function vec_mule [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_mule( UScons1, UScons2 );
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ for( i=0; i< 4; i++ )
+ if (UIaux1.e[i] != (USaux1.e[2*i] * USaux2.e[2*i]))
+ err++;
+ if (err)
+ printf("Function vec_mule [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_mule [type unsigned short] ===> OK\n");
+
+/* Function vec_mulo */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Saux1.v = vec_mulo( Ccons1, Ccons2 );
+ Caux1.v = Ccons1;
+ Caux2.v = Ccons2;
+ for( i=0; i< 4; i++ )
+ if (Saux1.e[i] != (Caux1.e[2*i+1]*Caux2.e[2*i+1]))
+ err++;
+ if (err)
+ printf("Function vec_mulo [type char] ===> Error\n");
+ else
+ printf("Function vec_mulo [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_mulo( UCcons1, UCcons2 );
+ UCaux1.v = UCcons1;
+ UCaux2.v = UCcons2;
+ for( i=0; i< 4; i++ )
+ if (USaux1.e[i] != (UCaux1.e[2*i+1]*UCaux2.e[2*i+1]))
+ err++;
+ if (err)
+ printf("Function vec_mulo [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_mulo [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_mulo( Scons1, Scons2 );
+ Saux1.v = Scons1;
+ Saux2.v = Scons2;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != (Saux1.e[2*i+1]*Saux2.e[2*i+1]))
+ err++;
+ if (err)
+ printf("Function vec_mulo [type short] ===> Error\n");
+ else
+ printf("Function vec_mulo [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_mulo( UScons1, UScons2 );
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ for( i=0; i< 4; i++ )
+ if (UIaux1.e[i] != (USaux1.e[2*i+1]*USaux2.e[2*i+1]))
+ err++;
+ if (err)
+ printf("Function vec_mulo [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_mulo [type unsigned short] ===> OK\n");
+
+#if defined TEST_FLOATS
+/* Function vec_nmsub */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_nmsub( Fcons1, Fcons2, Fcons3 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ Faux4.v = Fcons3;
+ for( i=0; i< 4; i++ )
+ {
+ if (Faux1.e[i] != (-Faux2.e[i]*Faux3.e[i]+Faux4.e[i]))
+ err++;
+ }
+ if (err)
+ printf("Function vec_nmsub [type float] ===> Error\n");
+ else
+ printf("Function vec_nmsub [type float] ===> OK\n");
+#endif
+
+/* Function vec_nor */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_nor( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ if (Caux1.e[i] != ~(Caux2.e[i] | Caux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_nor [type char] ===> Error\n");
+ else
+ printf("Function vec_nor [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_nor( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux2.e[i] | UCaux3.e[i];
+ UCaux = ~UCaux;
+ if (UCaux1.e[i] != UCaux )
+ err++;
+ }
+ if (err)
+ printf("Function vec_nor [type unsigened char] ===> Error\n");
+ else
+ printf("Function vec_nor [type unsigened char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_nor( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ if (Saux1.e[i] != ~(Saux2.e[i] | Saux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_nor [type short] ===> Error\n");
+ else
+ printf("Function vec_nor [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_nor( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = USaux2.e[i] | USaux3.e[i];
+ USaux = ~USaux;
+ if (USaux1.e[i] != USaux )
+ err++;
+ }
+ if (err)
+ printf("Function vec_nor [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_nor [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_nor( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != ~(Iaux2.e[i] | Iaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_nor [type integer] ===> Error\n");
+ else
+ printf("Function vec_nor [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_nor( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ if (UIaux1.e[i] != ~(UIaux2.e[i] | UIaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_nor [type unsigened int] ===> Error\n");
+ else
+ printf("Function vec_nor [type unsigened int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_nor( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ Ivec1 = Faux1.i[i];
+ Ivec2 = Faux2.i[i];
+ Ivec3 = Faux3.i[i];
+ if ((Ivec1) != ~((Ivec2) | (Ivec3)))
+ err++;
+ }
+ if (err)
+ printf("Function vec_nor [type float] ===> Error\n");
+ else
+ printf("Function vec_nor [type float] ===> OK\n");
+#endif
+
+/* Function vec_or */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_or( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ if (Caux1.e[i] != (Caux2.e[i] | Caux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_or [type char] ===> Error\n");
+ else
+ printf("Function vec_or [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_or( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux2.e[i] | UCaux3.e[i];
+ if (UCaux1.e[i] != UCaux )
+ err++;
+ }
+ if (err)
+ printf("Function vec_or [type unsigened char] ===> Error\n");
+ else
+ printf("Function vec_or [type unsigened char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_or( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ if (Saux1.e[i] != (Saux2.e[i] | Saux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_or [type short] ===> Error\n");
+ else
+ printf("Function vec_or [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_or( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = USaux2.e[i] | USaux3.e[i];
+ if (USaux1.e[i] != USaux )
+ err++;
+ }
+ if (err)
+ printf("Function vec_or [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_or [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_or( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != (Iaux2.e[i] | Iaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_or [type integer] ===> Error\n");
+ else
+ printf("Function vec_or [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_or( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ if (UIaux1.e[i] != (UIaux2.e[i] | UIaux3.e[i]))
+ err++;
+ if (err)
+ printf("Function vec_or [type unsigened int] ===> Error\n");
+ else
+ printf("Function vec_or [type unsigened int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_or( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ Ivec1 = Faux1.i[i];
+ Ivec2 = Faux2.i[i];
+ Ivec3 = Faux3.i[i];
+ if ((Ivec1) != ((Ivec2) | (Ivec3)))
+ err++;
+ }
+ if (err)
+ printf("Function vec_or [type float] ===> Error\n");
+ else
+ printf("Function vec_or [type float] ===> OK\n");
+#endif
+
+ return 0;
+}
+
+
+
+
+int part3( )
+{
+ TvecChar Caux1, Caux2, Caux3;//, Caux4;
+ TvecUChar UCaux1, UCaux2, UCaux3, UCaux4;
+ TvecShort Saux1, Saux2, Saux3;//, Saux4;
+ TvecUShort USaux1, USaux2, USaux3, USaux4;
+ TvecInt Iaux1, Iaux2, Iaux3;//, Iaux4;
+ TvecUInt UIaux1, UIaux2, UIaux3, UIaux4;
+#if defined TEST_FLOATS
+ TvecFloat Faux1, Faux2, Faux3;//, Faux4;
+#endif
+
+ int i, err, /*j,*/ b;//, bAux;
+#if defined TEST_FLOATS
+ signed int Ivec1, Ivec2;//, Ivec3;
+#endif
+// signed short *Svec1;
+ unsigned int *UIvec1;
+ unsigned short *USvec1;
+ unsigned char *UCvec1;
+#if defined TEST_FLOATS
+ // float *Fvec1;
+#endif
+
+ /* For saturated rutines */
+// long long int LLaux;
+
+#if defined TEST_FLOATS
+ float Faux;
+#endif
+ signed int Iaux;//, I1, I2;
+ unsigned int UIaux;//, UI1, UI2;
+ signed short Saux;
+ unsigned short USaux;
+ signed char Caux;
+ unsigned char UCaux;
+
+ union
+ {
+ float f;
+ signed int si;
+ unsigned int ui;
+ signed short ss[2];
+ unsigned short us[2];
+ signed char sc[4];
+ unsigned char uc[4];
+ } INTunion1, INTunion2;
+
+ union
+ {
+ signed short ss;
+ unsigned short us;
+ signed char sc[2];
+ unsigned char uc[2];
+ } SHOunion1, SHOunion2;
+
+
+#if defined (GCC_COMPILER)
+ vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127};
+ vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+ vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
+ vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3};
+ vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000};
+ vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767};
+ vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3};
+ vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1};
+ vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4};
+ vector signed int Icons1 = (vector signed int){-4, -1, 1, 4};
+ vector signed int Icons2 = (vector signed int){1, 1, 1, 1};
+ vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF};
+ vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1};
+ vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1};
+ vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2};
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999};
+ vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0};
+ vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0};
+#endif
+
+#elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+ vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127);
+ vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
+ vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+ vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3);
+ vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000);
+ vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767);
+ vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3);
+ vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1);
+ vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4);
+ vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4);
+ vector signed int Icons2 = (vector signed int)(1, 1, 1, 1);
+ vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF);
+ vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1);
+ vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1);
+ vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2);
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999);
+ vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0);
+ vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0);
+#endif
+
+#endif
+
+
+/* Variables to be allocated with calloc_vec (16 bytes aligned) */
+ unsigned char *UCmem = (unsigned char*)calloc_vec( 1, sizeof(vector unsigned char) );
+ signed char *Cmem = (signed char*)calloc_vec( 1, sizeof(vector signed char) );
+ unsigned short *USmem = (unsigned short*)calloc_vec( 1, sizeof(vector unsigned short) );
+ signed short *Smem = (signed short*)calloc_vec( 1, sizeof(vector signed short) );
+ unsigned int *UImem = (unsigned int*)calloc_vec( 1, sizeof(vector unsigned int) );
+ signed int *Imem = (signed int*)calloc_vec( 1, sizeof(vector signed int) );
+#if defined TEST_FLOATS
+ float *Fmem = (float*)calloc_vec( 1, sizeof(vector float) );
+#endif
+
+/* Function vec_pack */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_pack( Scons1, Scons2 );
+ Saux1.v = Scons1;
+ Saux2.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ SHOunion1.ss = Saux1.e[i];
+ if (Caux1.e[i] != SHOunion1.sc[1])
+ err++;
+ SHOunion1.ss = Saux2.e[i];
+ if (Caux1.e[i+8] != SHOunion1.sc[1])
+ err++;
+ }
+ if (err)
+ printf("Function vec_pack [type char] ===> Error\n");
+ else
+ printf("Function vec_pack [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_pack( UScons1, UScons2 );
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ SHOunion1.ss = USaux1.e[i];
+ if (UCaux1.e[i] != SHOunion1.uc[1])
+ err++;
+ SHOunion1.ss = USaux2.e[i];
+ if (UCaux1.e[i+8] != SHOunion1.uc[1])
+ err++;
+ }
+ if (err)
+ printf("Function vec_pack [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_pack [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_pack( Icons1, Icons2 );
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ INTunion1.si = Iaux1.e[i];
+ if (Saux1.e[i] != INTunion1.ss[1])
+ err++;
+ INTunion1.si = Iaux2.e[i];
+ if (Saux1.e[i+4] != INTunion1.ss[1])
+ err++;
+ }
+ if (err)
+ printf("Function vec_pack [type short] ===> Error\n");
+ else
+ printf("Function vec_pack [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_pack( UIcons1, UIcons2 );
+ UIaux1.v = UIcons1;
+ UIaux2.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ INTunion1.ui = UIaux1.e[i];
+ if (USaux1.e[i] != INTunion1.us[1])
+ err++;
+ INTunion1.ui = UIaux2.e[i];
+ if (USaux1.e[i+4] != INTunion1.us[1])
+ err++;
+ }
+ if (err)
+ printf("Function vec_pack [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_pack [type unsigned short] ===> OK\n");
+
+/* Function vec_packpx */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_packpx [Vector Pack Pixel] not checked\n");
+
+/* Function vec_packs */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_packs( Scons1, Scons2 );
+ Saux1.v = Scons1;
+ Saux2.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (Saux1.e[i]>127)
+ Caux = 127;
+ else if (Saux1.e[i]<(-128))
+ Caux = -128;
+ else
+ Caux = (signed char)Saux1.e[i];
+ if (Caux1.e[i] != Caux)
+ err++;
+ if (Saux2.e[i]>127)
+ Caux = 127;
+ else if (Saux2.e[i]<(-128))
+ Caux = -128;
+ else
+ Caux = (signed char)Saux2.e[i];
+ if (Caux1.e[i+8] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_packs [type char] ===> Error\n");
+ else
+ printf("Function vec_packs [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_packs( UScons1, UScons2 );
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (USaux1.e[i]>255)
+ UCaux = 255;
+ else
+ UCaux = (unsigned char)USaux1.e[i];
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ if (USaux2.e[i]>255)
+ UCaux = 255;
+ else
+ UCaux = (unsigned char)USaux2.e[i];
+ if (UCaux1.e[i+8] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_packs [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_packs [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_packs( Icons1, Icons2 );
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Iaux1.e[i]>32767)
+ Saux = 32767;
+ else if (Iaux1.e[i]<(-32768))
+ Saux = -32768;
+ else
+ Saux = (signed char)Iaux1.e[i];
+ if (Saux1.e[i] != Saux)
+ err++;
+ if (Iaux2.e[i]>32767)
+ Saux = 32767;
+ else if (Iaux2.e[i]<(-32768))
+ Saux = -32768;
+ else
+ Saux = (signed char)Iaux2.e[i];
+ if (Saux1.e[i+4] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_packs [type short] ===> Error\n");
+ else
+ printf("Function vec_packs [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_packs( UIcons1, UIcons2 );
+ UIaux1.v = UIcons1;
+ UIaux2.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (UIaux1.e[i]>65535)
+ USaux = 65535;
+ else
+ USaux = (unsigned char)UIaux1.e[i];
+ if (USaux1.e[i] != USaux)
+ err++;
+ if (UIaux2.e[i]>65535)
+ USaux = 65535;
+ else
+ USaux = (unsigned char)UIaux2.e[i];
+ if (USaux1.e[i+4] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_packs [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_packs [type unsigned short] ===> OK\n");
+
+/* Function vec_packsu */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux1.v = vec_packsu( Scons1, Scons2 );
+ Saux1.v = Scons1;
+ Saux2.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (Saux1.e[i]>255)
+ UCaux = 255;
+ else if (Saux1.e[i]<0)
+ UCaux = 0;
+ else
+ UCaux = (unsigned char)Saux1.e[i];
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ if (Saux2.e[i]>255)
+ UCaux = 255;
+ else if (Saux2.e[i]<0)
+ UCaux = 0;
+ else
+ UCaux = (unsigned char)Saux2.e[i];
+ if (UCaux1.e[i+8] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_packsu [type char] ===> Error\n");
+ else
+ printf("Function vec_packsu [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_packsu( UScons1, UScons2 );
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ if (USaux1.e[i]>255)
+ UCaux = 255;
+ else
+ UCaux = (unsigned char)USaux1.e[i];
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ if (USaux2.e[i]>255)
+ UCaux = 255;
+ else
+ UCaux = (unsigned char)USaux2.e[i];
+ if (UCaux1.e[i+8] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_packsu [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_packsu [type unsigned char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_packsu( Icons1, Icons2 );
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (Iaux1.e[i]>65535)
+ USaux = 65535;
+ else if (Iaux1.e[i]<0)
+ USaux = 0;
+ else
+ USaux = (unsigned short)Iaux1.e[i];
+ if (USaux1.e[i] != USaux)
+ err++;
+ if (Iaux2.e[i]>65535)
+ USaux = 65535;
+ else if (Iaux2.e[i]<0)
+ USaux = 0;
+ else
+ USaux = (unsigned short)Iaux2.e[i];
+ if (USaux1.e[i+4] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_packsu [type short] ===> Error\n");
+ else
+ printf("Function vec_packsu [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_packsu( UIcons1, UIcons2 );
+ UIaux1.v = UIcons1;
+ UIaux2.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ if (UIaux1.e[i]>65535)
+ USaux = 65535;
+ else
+ USaux = (unsigned char)UIaux1.e[i];
+ if (USaux1.e[i] != USaux)
+ err++;
+ if (UIaux2.e[i]>65535)
+ USaux = 65535;
+ else
+ USaux = (unsigned char)UIaux2.e[i];
+ if (USaux1.e[i+4] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_packsu [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_packsu [type unsigned short] ===> OK\n");
+
+/* Function vec_perm */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ printf("Function vec_perm [Vector Permute] not checked\n");
+
+#if defined TEST_FLOATS
+/* Function vec_re */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_re( Fcons1 );
+ Faux2.v = Fcons1;
+ for( i=0; i< 4; i++ )
+ {
+ Faux = 1/Faux2.e[i];
+ if (Faux!=0.0)
+ Faux = (Faux - Faux1.e[i])/Faux;
+ else
+ Faux = Faux - Faux1.e[i];
+ if (Faux>(1.0/4096.0))
+ err++;
+ }
+ if (err)
+ printf("Function vec_re [type float] ===> Error\n");
+ else
+ printf("Function vec_re [type float] ===> OK\n");
+#endif
+
+/* Function vec_rl */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_rl( Ccons1, UCcons3 );
+ Caux2.v = Ccons1;
+ UCaux1.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ b = UCaux1.e[i];
+ UCvec1 = (unsigned char *)(&Caux2.e[i]);
+ Caux = ((*UCvec1)>>(8-b)) | ((*UCvec1)<<b);
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_rl [type char] ===> Error\n");
+ else
+ printf("Function vec_rl [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_rl( UCcons1, UCcons3 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ b = UCaux3.e[i];
+ UCaux = (UCaux2.e[i]>>(8-b)) | (UCaux2.e[i]<<b);
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_rl [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_rl [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_rl( Scons1, UScons3 );
+ Saux2.v = Scons1;
+ USaux1.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ b = USaux1.e[i];
+ USvec1 = (unsigned short *)(&Saux2.e[i]);
+ Saux = ((*USvec1)>>(16-b)) | ((*USvec1)<<b);
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_rl [type short] ===> Error\n");
+ else
+ printf("Function vec_rl [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_rl( UScons1, UScons3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ b = USaux3.e[i];
+ USaux = (USaux2.e[i]>>(16-b)) | (USaux2.e[i]<<b);
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_rl [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_rl [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_rl( Icons1, UIcons3 );
+ Iaux2.v = Icons1;
+ UIaux1.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ b = UIaux1.e[i];
+ UIvec1 = (unsigned int *)(&Iaux2.e[i]);
+ Iaux = ((*UIvec1)>>(32-b)) | ((*UIvec1)<<b);
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_rl [type integer] ===> Error\n");
+ else
+ printf("Function vec_rl [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_rl( UIcons1, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ b = UIaux3.e[i];
+ UIaux = (UIaux2.e[i]>>(32-b)) | (UIaux2.e[i]<<b);
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_rl [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_rl [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+/* Function vec_round */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_round( Fcons1 );
+ Faux2.v = Fcons1;
+ for( i=0; i< 4; i++ )
+ {
+ Faux = floor(Faux2.e[i]);
+ if ((Faux2.e[i]-Faux)>0.5)
+ Faux = Faux + 1.0;
+ else if (((Faux2.e[i]-Faux)==0.5)&&(Iaux%2))
+ Faux = Faux + 1.0;
+ if (Faux1.e[i] != Faux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_round [type float] ===> Error\n");
+ else
+ printf("Function vec_round [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_rsqrte */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = vec_rsqrte( Fcons1 );
+ Faux2.v = Fcons1;
+ for( i=0; i< 4; i++ )
+ {
+ Faux = sqrtf(Faux2.e[i]);
+ if (Faux>0.0)
+ Faux = (Faux - Faux1.e[i])/Faux;
+ else if (Faux==0.0)
+ Faux = Faux - Faux1.e[i];
+ if (Faux>(1.0/4096.0))
+ err++;
+ }
+ if (err)
+ printf("Function vec_rsqrte [type float] ===> Error\n");
+ else
+ printf("Function vec_rsqrte [type float] ===> OK\n");
+#endif
+
+/* Function vec_sel */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_sel( Ccons1, Ccons2, UCcons1 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ UCaux1.v = UCcons1;
+ for( i=0; i< 16; i++ )
+ {
+ Caux = (Caux2.e[i] & (~UCaux1.e[i])) | (Caux3.e[i] & UCaux1.e[i]);
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sel [type char] ===> Error\n");
+ else
+ printf("Function vec_sel [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_sel( UCcons1, UCcons2, UCcons3 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ UCaux4.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = (UCaux2.e[i] & (~UCaux4.e[i])) | (UCaux3.e[i] & UCaux4.e[i]);
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sel [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sel [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_sel( Scons1, Scons2, UScons1 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ USaux1.v = UScons1;
+ for( i=0; i< 8; i++ )
+ {
+ Saux = (Saux2.e[i] & (~USaux1.e[i])) | (Saux3.e[i] & USaux1.e[i]);
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sel [type short] ===> Error\n");
+ else
+ printf("Function vec_sel [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_sel( UScons1, UScons2, UScons3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ USaux4.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = (USaux2.e[i] & (~USaux4.e[i])) | (USaux3.e[i] & USaux4.e[i]);
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sel [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_sel [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_sel( Icons1, Icons2, UIcons1 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ UIaux1.v = UIcons1;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = (Iaux2.e[i] & (~UIaux1.e[i])) | (Iaux3.e[i] & UIaux1.e[i]);
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sel [type integer] ===> Error\n");
+ else
+ printf("Function vec_sel [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_sel( UIcons1, UIcons2, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ UIaux4.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = (UIaux2.e[i] & (~UIaux4.e[i])) | (UIaux3.e[i] & UIaux4.e[i]);
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sel [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_sel [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_sel( Fcons1, Fcons2, UIcons1 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ UIaux1.v = UIcons1;
+ for( i=0; i< 4; i++ )
+ {
+ Ivec1 = Faux2.i[i];
+ Ivec2 = Faux3.i[i];
+ Iaux = (Ivec1 & (~UIaux1.e[i])) | (Ivec2 & UIaux1.e[i]);
+ Ivec1 = Faux1.i[i];
+ if ((Ivec1) != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sel [type float] ===> Error\n");
+ else
+ printf("Function vec_sel [type float] ===> OK\n");
+#endif
+
+/* Function vec_sl */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_sl( Ccons1, UCcons3 );
+ Caux2.v = Ccons1;
+ UCaux1.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ b = UCaux1.e[i]%(128/16);
+ Caux = Caux2.e[i] << b;
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sl [type char] ===> Error\n");
+ else
+ printf("Function vec_sl [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_sl( UCcons1, UCcons3 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ b = UCaux3.e[i]%(128/16);
+ UCaux = UCaux2.e[i] << b;
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sl [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sl [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_sl( Scons1, UScons3 );
+ Saux2.v = Scons1;
+ USaux1.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ b = USaux1.e[i]%(128/8);
+ Saux = Saux2.e[i] << b;
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sl [type short] ===> Error\n");
+ else
+ printf("Function vec_sl [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_sl( UScons1, UScons3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ b = USaux3.e[i]%(128/8);
+ USaux = USaux2.e[i] << b;
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sl [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_sl [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_sl( Icons1, UIcons3 );
+ Iaux2.v = Icons1;
+ UIaux1.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ b = UIaux1.e[i]%(128/4);
+ Iaux = Iaux2.e[i] << b;
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sl [type int] ===> Error\n");
+ else
+ printf("Function vec_sl [type int] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_sl( UIcons1, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ b = UIaux3.e[i]%(128/4);
+ UIaux = UIaux2.e[i] << b;
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sl [type unsigned integer] ===> Error\n");
+ else
+ printf("Function vec_sl [type unsigned integer] ===> OK\n");
+
+/* Function vec_sld */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ b = 3;
+ Caux1.v = vec_sld( Ccons1, Ccons2, 3 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ {
+ if ((i+b)<16)
+ {
+ if (Caux1.e[i] != Caux2.e[i+b])
+ err++;
+ }
+ else
+ {
+ if (Caux1.e[i] != Caux3.e[i+b-16])
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sld [type char] ===> Error\n");
+ else
+ printf("Function vec_sld [type char] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ UCaux1.v = vec_sld( UCcons1, UCcons2, 3 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ if ((i+b)<16)
+ {
+ if (UCaux1.e[i] != UCaux2.e[i+b])
+ err++;
+ }
+ else
+ {
+ if (UCaux1.e[i] != UCaux3.e[i+b-16])
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sld [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sld [type unsigned char] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ Saux1.v = vec_sld( Scons1, Scons2, 3 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 16; i++ )
+ {
+ SHOunion1.ss = Saux1.e[i/2];
+ if ((i+b)<16)
+ SHOunion2.ss = Saux2.e[(i+b)/2];
+ else
+ SHOunion2.ss = Saux3.e[(i+b-16)/2];
+ if (SHOunion1.sc[i%2] != SHOunion2.sc[(i+b)%2])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sld [type short] ===> Error\n");
+ else
+ printf("Function vec_sld [type short] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ USaux1.v = vec_sld( UScons1, UScons2, 3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 16; i++ )
+ {
+ SHOunion1.us = USaux1.e[i/2];
+ if ((i+b)<16)
+ SHOunion2.us = USaux2.e[(i+b)/2];
+ else
+ SHOunion2.us = USaux3.e[(i+b-16)/2];
+ if (SHOunion1.uc[i%2] != SHOunion2.uc[(i+b)%2])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sld [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_sld [type unsigned short] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ Iaux1.v = vec_sld( Icons1, Icons2, 3 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.si = Iaux1.e[i/4];
+ if ((i+b)<16)
+ INTunion2.si = Iaux2.e[(i+b)/4];
+ else
+ INTunion2.si = Iaux3.e[(i+b-16)/4];
+ if (INTunion1.sc[i%4] != INTunion2.sc[(i+b)%4])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sld [type integer] ===> Error\n");
+ else
+ printf("Function vec_sld [type integer] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ UIaux1.v = vec_sld( UIcons1, UIcons2, 3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.ui = UIaux1.e[i/4];
+ if ((i+b)<16)
+ INTunion2.ui = UIaux2.e[(i+b)/4];
+ else
+ INTunion2.ui = UIaux3.e[(i+b-16)/4];
+ if (INTunion1.uc[i%4] != INTunion2.uc[(i+b)%4])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sld [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_sld [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ b = 3;
+ Faux1.v = vec_sld( Fcons1, Fcons2, 3 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.f = Faux1.e[i/4];
+ if ((i+b)<16)
+ INTunion2.f = Faux2.e[(i+b)/4];
+ else
+ INTunion2.f = Faux3.e[(i+b-16)/4];
+ if (INTunion1.sc[i%4] != INTunion2.sc[(i+b)%4])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sld [type float] ===> Error\n");
+ else
+ printf("Function vec_sld [type float] ===> OK\n");
+#endif
+
+/* Function vec_sll */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_sll( Ccons1, UCcons2 );
+ Caux2.v = Ccons1;
+ UCaux1.v = UCcons2;
+ b = UCaux1.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux1.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ for( i=0; i< 16; i++ )
+ {
+ UCvec1 = (unsigned char *)(&Caux2.e[i]);
+ Caux = UCvec1[0]<<b;
+ if (i != 15)
+ Caux = Caux | (UCvec1[1]>>(8-b));
+ if (Caux != Caux1.e[i])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sll [type char] ===> Error\n");
+ else
+ printf("Function vec_sll [type char] ===> OK\n");
+ }
+
+ UCaux1.v = vec_sll( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ b = UCaux3.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux3.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ for( i=0; i< 16; i++ )
+ {
+ UCvec1 = (unsigned char *)(&UCaux2.e[i]);
+ UCaux = UCvec1[0]<<b;
+ if (i != 15)
+ UCaux = UCaux | (UCvec1[1]>>(8-b));
+ if (UCaux != UCaux1.e[i])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sll [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sll [type unsigned char] ===> OK\n");
+ }
+
+ err = 0;
+ Saux1.v = vec_sll( Scons1, UCcons2 );
+ Saux2.v = Scons1;
+ UCaux1.v = UCcons2;
+ b = UCaux1.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux1.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ for( i=0; i< 8; i++ )
+ {
+ USvec1 = (unsigned short *)(&Saux2.e[i]);
+ Saux = USvec1[0]<<b;
+ if (i != 7)
+ Saux = Saux | (USvec1[1]>>(16-b));
+ if (Saux != Saux1.e[i])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sll [type short] ===> Error\n");
+ else
+ printf("Function vec_sll [type short] ===> OK\n");
+ }
+
+ USaux1.v = vec_sll( UScons1, UCcons2 );
+ USaux2.v = UScons1;
+ UCaux1.v = UCcons2;
+ b = UCaux1.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux1.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ for( i=0; i< 8; i++ )
+ {
+ USvec1 = (unsigned short *)(&USaux2.e[i]);
+ USaux = USvec1[0]<<b;
+ if (i != 7)
+ USaux = USaux | (USvec1[1]>>(16-b));
+ if (USaux != USaux1.e[i])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sll [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sll [type unsigned char] ===> OK\n");
+ }
+
+ err = 0;
+ Iaux1.v = vec_sll( Icons1, UCcons2 );
+ Iaux2.v = Icons1;
+ UCaux1.v = UCcons2;
+ b = UCaux1.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux1.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ for( i=0; i< 4; i++ )
+ {
+ UIvec1 = (unsigned int *)(&Iaux2.e[i]);
+ Iaux = UIvec1[0]<<b;
+ if (i != 3)
+ Iaux = Iaux | (UIvec1[1]>>(32-b));
+ if (Iaux != Iaux1.e[i])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sll [type integer] ===> Error\n");
+ else
+ printf("Function vec_sll [type integer] ===> OK\n");
+ }
+
+ UIaux1.v = vec_sll( UIcons1, UCcons2 );
+ UIaux2.v = UIcons1;
+ UCaux1.v = UCcons2;
+ b = UCaux1.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux1.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ for( i=0; i< 4; i++ )
+ {
+ UIvec1 = (unsigned int *)(&UIaux2.e[i]);
+ UIaux = UIvec1[0]<<b;
+ if (i != 3)
+ UIaux = UIaux | (UIvec1[1]>>(32-b));
+ if (UIaux != UIaux1.e[i])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sll [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_sll [type unsigned int] ===> OK\n");
+ }
+
+/* Function vec_slo */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_slo( Ccons3, Ccons1 );
+ Caux2.v = Ccons3;
+ Caux3.v = Ccons1;
+ b = (Caux3.e[15] & 0x78) >> 3;
+ for( i=0; i< 16; i++ )
+ {
+ if ((i+b)<16)
+ {
+ if (Caux1.e[i] != Caux2.e[i+b])
+ err++;
+ }
+ else
+ {
+ if (Caux1.e[i] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_slo [type char] ===> Error\n");
+ else
+ printf("Function vec_slo [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_slo( UCcons3, UCcons1 );
+ UCaux2.v = UCcons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >> 3;
+ for( i=0; i< 16; i++ )
+ {
+ if ((i+b)<16)
+ {
+ if (UCaux1.e[i] != UCaux2.e[i+b])
+ err++;
+ }
+ else
+ {
+ if (UCaux1.e[i] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_slo [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_slo [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_slo( Scons3, UCcons1 );
+ Saux2.v = Scons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >> 3;
+ for( i=0; i< 16; i++ )
+ {
+ SHOunion1.ss = Saux1.e[i/2];
+ if ((i+b)<16)
+ SHOunion2.ss = Saux2.e[(i+b)/2];
+ else
+ SHOunion2.ss = 0;
+ if (SHOunion1.sc[i%2] != SHOunion2.sc[(i+b)%2])
+ err++;
+ }
+ if (err)
+ printf("Function vec_slo [type short] ===> Error\n");
+ else
+ printf("Function vec_slo [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_slo( UScons3, UCcons1 );
+ USaux2.v = UScons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >> 3;
+ for( i=0; i< 16; i++ )
+ {
+ SHOunion1.us = USaux1.e[i/2];
+ if ((i+b)<16)
+ SHOunion2.us = USaux2.e[(i+b)/2];
+ else
+ SHOunion2.us = 0;
+ if (SHOunion1.uc[i%2] != SHOunion2.uc[(i+b)%2])
+ err++;
+ }
+ if (err)
+ printf("Function vec_slo [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_slo [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_slo( Icons3, UCcons1 );
+ Iaux2.v = Icons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >> 3;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.si = Iaux1.e[i/4];
+ if ((i+b)<16)
+ INTunion2.si = Iaux2.e[(i+b)/4];
+ else
+ INTunion2.si = 0;
+ if (INTunion1.sc[i%4] != INTunion2.sc[(i+b)%4])
+ err++;
+ }
+ if (err)
+ printf("Function vec_slo [type integer] ===> Error\n");
+ else
+ printf("Function vec_slo [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_slo( UIcons3, UCcons1 );
+ UIaux2.v = UIcons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >> 3;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.ui = UIaux1.e[i/4];
+ if ((i+b)<16)
+ INTunion2.ui = UIaux2.e[(i+b)/4];
+ else
+ INTunion2.ui = 0;
+ if (INTunion1.uc[i%4] != INTunion2.uc[(i+b)%4])
+ err++;
+ }
+ if (err)
+ printf("Function vec_slo [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_slo [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_slo( Fcons3, UCcons1 );
+ Faux2.v = Fcons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >> 3;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.f = Faux1.e[i/4];
+ if ((i+b)<16)
+ INTunion2.f = Faux2.e[(i+b)/4];
+ else
+ INTunion2.si = 0;
+ if (INTunion1.sc[i%4] != INTunion2.sc[(i+b)%4])
+ err++;
+ }
+ if (err)
+ printf("Function vec_slo [type float] ===> Error\n");
+ else
+ printf("Function vec_slo [type float] ===> OK\n");
+#endif
+
+/* Function vec_splat */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ b = 3;
+ Caux1.v = vec_splat( Ccons1, 3 );
+ Caux2.v = Ccons1;
+ for( i=0; i< 16; i++ )
+ if (Caux1.e[i] != Caux2.e[b])
+ err++;
+ if (err)
+ printf("Function vec_splat [type char] ===> Error\n");
+ else
+ printf("Function vec_splat [type char] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ UCaux1.v = vec_splat( UCcons1, 3 );
+ UCaux2.v = UCcons1;
+ for( i=0; i< 16; i++ )
+ if (UCaux1.e[i] != UCaux2.e[b])
+ err++;
+ if (err)
+ printf("Function vec_splat [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_splat [type unsigned char] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ Saux1.v = vec_splat( Scons1, 3 );
+ Saux2.v = Scons1;
+ for( i=0; i< 8; i++ )
+ if (Saux1.e[i] != Saux2.e[b])
+ err++;
+ if (err)
+ printf("Function vec_splat [type short] ===> Error\n");
+ else
+ printf("Function vec_splat [type short] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ USaux1.v = vec_splat( UScons1, 3 );
+ USaux2.v = UScons1;
+ for( i=0; i< 8; i++ )
+ if (USaux1.e[i] != USaux2.e[b])
+ err++;
+ if (err)
+ printf("Function vec_splat [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_splat [type unsigned short] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ Iaux1.v = vec_splat( Icons1, 3 );
+ Iaux2.v = Icons1;
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != Iaux2.e[b])
+ err++;
+ if (err)
+ printf("Function vec_splat [type integer] ===> Error\n");
+ else
+ printf("Function vec_splat [type integer] ===> OK\n");
+
+ err = 0;
+ b = 3;
+ UIaux1.v = vec_splat( UIcons1, 3 );
+ UIaux2.v = UIcons1;
+ for( i=0; i< 4; i++ )
+ if (UIaux1.e[i] != UIaux2.e[b])
+ err++;
+ if (err)
+ printf("Function vec_splat [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_splat [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ b = 3;
+ Faux1.v = vec_splat( Fcons1, 3 );
+ Faux2.v = Fcons1;
+ for( i=0; i< 4; i++ )
+ if (Faux1.e[i] != Faux2.e[b])
+ err++;
+ if (err)
+ printf("Function vec_splat [type float] ===> Error\n");
+ else
+ printf("Function vec_splat [type float] ===> OK\n");
+#endif
+
+/* Function vec_splat_s8 */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux = 15;
+ Caux1.v = vec_splat_s8( 15 );
+ for( i=0; i< 16; i++ )
+ if (Caux1.e[i] != Caux)
+ err++;
+ if (err)
+ printf("Function vec_splat_s8 [type char] ===> Error\n");
+ else
+ printf("Function vec_splat_s8 [type char] ===> OK\n");
+
+/* Function vec_splat_s16 */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Saux = 15;
+ Saux1.v = vec_splat_s16( 15 );
+ for( i=0; i< 8; i++ )
+ if (Saux1.e[i] != Saux)
+ err++;
+ if (err)
+ printf("Function vec_splat_s16 [type short] ===> Error\n");
+ else
+ printf("Function vec_splat_s16 [type short] ===> OK\n");
+
+/* Function vec_splat_s32 */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Iaux = 15;
+ Iaux1.v = vec_splat_s32( 15 );
+ for( i=0; i< 4; i++ )
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ if (err)
+ printf("Function vec_splat_s32 [type integer] ===> Error\n");
+ else
+ printf("Function vec_splat_s32 [type integer] ===> OK\n");
+
+/* Function vec_splat_u8 */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux = 15;
+ UCaux1.v = vec_splat_u8( 15 );
+ for( i=0; i< 16; i++ )
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ if (err)
+ printf("Function vec_splat_u8 [type unsig. char] ===> Error\n");
+ else
+ printf("Function vec_splat_u8 [type unsig. char] ===> OK\n");
+
+/* Function vec_splat_u16 */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ USaux = 15;
+ USaux1.v = vec_splat_u16( 15 );
+ for( i=0; i< 8; i++ )
+ if (USaux1.e[i] != Saux)
+ err++;
+ if (err)
+ printf("Function vec_splat_u16 [type unsg. short] ===> Error\n");
+ else
+ printf("Function vec_splat_u16 [type unsg. short] ===> OK\n");
+
+/* Function vec_splat_u32 */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UIaux = 15;
+ UIaux1.v = vec_splat_u32( 15 );
+ for( i=0; i< 4; i++ )
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ if (err)
+ printf("Function vec_splat_u32 [type unsig. int] ===> Error\n");
+ else
+ printf("Function vec_splat_u32 [type unsig. int] ===> OK\n");
+
+/* Function vec_sr */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_sr( Ccons3, UCcons3 );
+ Caux2.v = Ccons3;
+ UCaux3.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ SHOunion1.sc[0] = Caux2.e[i];
+ SHOunion1.uc[0] = SHOunion1.uc[0] >> (UCaux3.e[i]%8);
+ if (Caux1.e[i] != SHOunion1.sc[0])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sr [type char] ===> Error\n");
+ else
+ printf("Function vec_sr [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_sr( UCcons1, UCcons3 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux2.e[i] >> (UCaux3.e[i]%8);
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sr [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sr [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_sr( Scons3, UScons3 );
+ Saux2.v = Scons3;
+ USaux3.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ SHOunion1.ss = Saux2.e[i];
+ SHOunion1.us = SHOunion1.us >> (USaux3.e[i]%16);
+ if (Saux1.e[i] != SHOunion1.ss)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sr [type short] ===> Error\n");
+ else
+ printf("Function vec_sr [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_sr( UScons1, UScons3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = USaux2.e[i] >> (USaux3.e[i]%16);
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sr [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_sr [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_sr( Icons3, UIcons3 );
+ Iaux2.v = Icons3;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ INTunion1.si = Iaux2.e[i];
+ INTunion1.ui = INTunion1.ui >> (UIaux3.e[i]%32);
+ if (Iaux1.e[i] != INTunion1.si)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sr [type integer] ===> Error\n");
+ else
+ printf("Function vec_sr [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_sr( UIcons1, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = UIaux2.e[i] >> (UIaux3.e[i]%32);
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sr [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_sr [type unsigned int] ===> OK\n");
+
+/* Function vec_sra */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_sra( Ccons3, UCcons3 );
+ Caux2.v = Ccons3;
+ UCaux3.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ Caux = Caux2.e[i] >> (UCaux3.e[i]%8);
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sra [type char] ===> Error\n");
+ else
+ printf("Function vec_sra [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_sra( UCcons1, UCcons3 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.uc[0] = UCaux2.e[i];
+ INTunion1.sc[0] = INTunion1.sc[0] >> (UCaux3.e[i]%8);
+ if (UCaux1.e[i] != INTunion1.uc[0])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sra [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sra [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_sra( Scons3, UScons3 );
+ Saux2.v = Scons3;
+ USaux3.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ Saux = Saux2.e[i] >> (USaux3.e[i]%16);
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sra [type short] ===> Error\n");
+ else
+ printf("Function vec_sra [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_sra( UScons1, UScons3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ INTunion1.us[0] = USaux2.e[i];
+ INTunion1.ss[0] = INTunion1.ss[0] >> (USaux3.e[i]%16);
+ if (USaux1.e[i] != INTunion1.us[0])
+ err++;
+ }
+ if (err)
+ printf("Function vec_sra [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_sra [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_sra( Icons3, UIcons3 );
+ Iaux2.v = Icons3;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i] >> (UIaux3.e[i]%32);
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sra [type integer] ===> Error\n");
+ else
+ printf("Function vec_sra [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_sra( UIcons1, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ INTunion1.ui = UIaux2.e[i];
+ INTunion1.si = INTunion1.si >> (UIaux3.e[i]%32);
+ if (UIaux1.e[i] != INTunion1.ui)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sra [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_sra [type unsigned int] ===> OK\n");
+
+/* Function vec_srl */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_srl( Ccons1, UCcons2 );
+ Caux2.v = Ccons1;
+ UCaux3.v = UCcons2;
+ b = UCaux3.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux3.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ Caux = 0;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.sc[0] = Caux2.e[i];
+ Caux = Caux | (INTunion1.uc[0]>>b);
+ if (Caux != Caux1.e[i])
+ err++;
+ Caux = INTunion1.uc[0]<<(8-b);
+ }
+ if (err)
+ printf("Function vec_srl [type char] ===> Error\n");
+ else
+ printf("Function vec_srl [type char] ===> OK\n");
+ }
+
+ err = 0;
+ UCaux1.v = vec_srl( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ b = UCaux3.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux3.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ UCaux = 0;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux | (UCaux2.e[i]>>b);
+ if (UCaux != UCaux1.e[i])
+ err++;
+ UCaux = UCaux2.e[i]<<(8-b);
+ }
+ if (err)
+ printf("Function vec_srl [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_srl [type unsigned char] ===> OK\n");
+ }
+
+ err = 0;
+ Saux1.v = vec_srl( Scons1, UCcons2 );
+ Saux2.v = Scons1;
+ UCaux3.v = UCcons2;
+ b = UCaux3.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux3.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ Saux = 0;
+ for( i=0; i< 8; i++ )
+ {
+ INTunion1.ss[0] = Saux2.e[i];
+ Saux = Saux | (INTunion1.us[0]>>b);
+ if (Saux != Saux1.e[i])
+ err++;
+ Saux = INTunion1.us[0]<<(16-b);
+ }
+ if (err)
+ printf("Function vec_srl [type short] ===> Error\n");
+ else
+ printf("Function vec_srl [type short] ===> OK\n");
+ }
+
+ err = 0;
+ USaux1.v = vec_srl( UScons1, UCcons2 );
+ USaux2.v = UScons1;
+ UCaux3.v = UCcons2;
+ b = UCaux3.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux3.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ USaux = 0;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = USaux | (USaux2.e[i]>>b);
+ if (USaux != USaux1.e[i])
+ err++;
+ USaux = USaux2.e[i]<<(16-b);
+ }
+ if (err)
+ printf("Function vec_srl [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_srl [type unsigned short] ===> OK\n");
+ }
+
+ err = 0;
+ Iaux1.v = vec_srl( Icons1, UCcons2 );
+ Iaux2.v = Icons1;
+ UCaux3.v = UCcons2;
+ b = UCaux3.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux3.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ Iaux = 0;
+ for( i=0; i< 4; i++ )
+ {
+ INTunion1.si = Iaux2.e[i];
+ Iaux = Iaux | (INTunion1.ui>>b);
+ if (Iaux != Iaux1.e[i])
+ err++;
+ Iaux = INTunion1.ui<<(32-b);
+ }
+ if (err)
+ printf("Function vec_srl [type integer] ===> Error\n");
+ else
+ printf("Function vec_srl [type integer] ===> OK\n");
+ }
+
+ err = 0;
+ UIaux1.v = vec_srl( UIcons1, UCcons2 );
+ UIaux2.v = UIcons1;
+ UCaux3.v = UCcons2;
+ b = UCaux3.e[15] & 0x7;
+ for( i=0; i< 15; i++ )
+ if ((UCaux3.e[i] & 0x7)!=b)
+ err++;
+ if (err)
+ {
+ printf("The three low-order bits of all byte elements in b must be the same\n");
+ printf("otherwise the value into d is undefined\n");
+ }
+ else
+ {
+ UIaux = 0;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = UIaux | (UIaux2.e[i]>>b);
+ if (UIaux != UIaux1.e[i])
+ err++;
+ UIaux = UIaux2.e[i]<<(32-b);
+ }
+ if (err)
+ printf("Function vec_srl [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_srl [type unsigned int] ===> OK\n");
+ }
+
+/* Function vec_sro */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_sro( Ccons3, Ccons1 );
+ Caux2.v = Ccons3;
+ Caux3.v = Ccons1;
+ b = (Caux3.e[15] & 0x78) >>3;
+ for( i=0; i< 16; i++ )
+ {
+ if ((i-b)>=0)
+ {
+ if (Caux1.e[i] != Caux2.e[i-b])
+ err++;
+ }
+ else
+ {
+ if (Caux1.e[i] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sro [type char] ===> Error\n");
+ else
+ printf("Function vec_sro [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_sro( UCcons3, UCcons1 );
+ UCaux2.v = UCcons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >>3;
+ for( i=0; i< 16; i++ )
+ {
+ if ((i-b)>=0)
+ {
+ if (UCaux1.e[i] != UCaux2.e[i-b])
+ err++;
+ }
+ else
+ {
+ if (UCaux1.e[i] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sro [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sro [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_sro( Scons3, Ccons1 );
+ Saux2.v = Scons3;
+ Caux3.v = Ccons1;
+ b = (Caux3.e[15] & 0x78) >>3;
+ for( i=0; i< 16; i++ )
+ {
+ SHOunion1.ss = Saux1.e[i/2];
+ if ((i-b)>=0)
+ {
+ SHOunion2.ss = Saux2.e[(i-b)/2];
+ if (SHOunion1.sc[i%2] != SHOunion2.sc[(i-b)%2])
+ err++;
+ }
+ else
+ {
+ if (SHOunion1.sc[i%2] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sro [type short] ===> Error\n");
+ else
+ printf("Function vec_sro [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_sro( UScons3, UCcons1 );
+ USaux2.v = UScons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >>3;
+ for( i=0; i< 16; i++ )
+ {
+ SHOunion1.us = USaux1.e[i/2];
+ if ((i-b)>=0)
+ {
+ SHOunion2.us = USaux2.e[(i-b)/2];
+ if (SHOunion1.uc[i%2] != SHOunion2.uc[(i-b)%2])
+ err++;
+ }
+ else
+ {
+ if (SHOunion1.uc[i%2] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sro [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_sro [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_sro( Icons3, Ccons1 );
+ Iaux2.v = Icons3;
+ Caux3.v = Ccons1;
+ b = (Caux3.e[15] & 0x78) >>3;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.si = Iaux1.e[i/4];
+ if ((i-b)>=0)
+ {
+ INTunion2.si = Iaux2.e[(i-b)/4];
+ if (INTunion1.sc[i%4] != INTunion2.sc[(i-b)%4])
+ err++;
+ }
+ else
+ {
+ if (INTunion1.sc[i%4] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sro [type integer] ===> Error\n");
+ else
+ printf("Function vec_sro [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_sro( UIcons3, UCcons1 );
+ UIaux2.v = UIcons3;
+ UCaux3.v = UCcons1;
+ b = (UCaux3.e[15] & 0x78) >>3;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.ui = UIaux1.e[i/4];
+ if ((i-b)>=0)
+ {
+ INTunion2.ui = UIaux2.e[(i-b)/4];
+ if (INTunion1.uc[i%4] != INTunion2.sc[(i-b)%4])
+ err++;
+ }
+ else
+ {
+ if (INTunion1.uc[i%4] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sro [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_sro [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_sro( Fcons3, Ccons1 );
+ Faux2.v = Fcons3;
+ Caux3.v = Ccons1;
+ b = (Caux3.e[15] & 0x78) >>3;
+ for( i=0; i< 16; i++ )
+ {
+ INTunion1.f = Faux1.e[i/4];
+ if ((i-b)>=0)
+ {
+ INTunion2.f = Faux2.e[(i-b)/4];
+ if (INTunion1.sc[i%4] != INTunion2.sc[(i-b)%4])
+ err++;
+ }
+ else
+ {
+ if (INTunion1.sc[i%4] != 0)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_sro [type float] ===> Error\n");
+ else
+ printf("Function vec_sro [type float] ===> OK\n");
+#endif
+
+/* Function vec_st */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux1.v = UCcons1;
+ vec_st( UCaux1.v, 0, UCmem );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]==UCmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_st [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_st [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Caux1.v = Ccons1;
+ vec_st( Caux1.v, 0, Cmem );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]==Cmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_st [type char] ===> Error\n");
+ else
+ printf("Function vec_st [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = UScons3;
+ vec_st( USaux1.v, 0, USmem );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]==USmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_st [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_st [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons1;
+ vec_st( Saux1.v, 0, Smem );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]==Smem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_st [type short] ===> Error\n");
+ else
+ printf("Function vec_st [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = UIcons1;
+ vec_st( UIaux1.v, 0, UImem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]==UImem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_st [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_st [type unsigned int] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = Icons1;
+ vec_st( Iaux1.v, 0, Imem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]==Imem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_st [type int] ===> Error\n");
+ else
+ printf("Function vec_st [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = Fcons1;
+ vec_st( Faux1.v, 0, Fmem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]==Fmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_st [type float] ===> Error\n");
+ else
+ printf("Function vec_st [type float] ===> OK\n");
+#endif
+
+/* Function vec_ste */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ b = 11;
+ UCaux1.v = UCcons1;
+ vec_ste( UCaux1.v, b, UCmem );
+ i = b;
+ if (UCaux1.e[i]!=UCmem[i]) err++;
+
+ if (err)
+ printf("Function vec_ste [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_ste [type unsigned char] ===> OK\n");
+
+ err = 0;
+ b = 11;
+ Caux1.v = Ccons1;
+ vec_ste( Caux1.v, b, Cmem );
+ i = b;
+ if (Caux1.e[i]!=Cmem[i]) err++;
+
+ if (err)
+ printf("Function vec_ste [type char] ===> Error\n");
+ else
+ printf("Function vec_ste [type char] ===> OK\n");
+
+ err = 0;
+ b = 11;
+ USaux1.v = UScons1;
+ vec_ste( USaux1.v, b, USmem );
+ i = b/2;
+ if (USaux1.e[i]!=USmem[i]) err++;
+ if (err)
+ printf("Function vec_ste [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_ste [type unsigned short] ===> OK\n");
+
+ err = 0;
+ b = 11;
+ Saux1.v = Scons1;
+ vec_ste( Saux1.v, b, Smem );
+ i = b/2;
+ if (Saux1.e[i]!=Smem[i]) err++;
+ if (err)
+ printf("Function vec_ste [type short] ===> Error\n");
+ else
+ printf("Function vec_ste [type short] ===> OK\n");
+
+ err = 0;
+ b = 11;
+ UIaux1.v = UIcons1;
+ vec_ste( UIaux1.v, b, UImem );
+ i = b/4;
+ if (UIaux1.e[i]!=UImem[i]) err++;
+ if (err)
+ printf("Function vec_ste [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_ste [type unsigned int] ===> OK\n");
+
+ err = 0;
+ b = 11;
+ Iaux1.v = Icons1;
+ vec_ste( Iaux1.v, b, Imem );
+ i = b/4;
+ if (Iaux1.e[i]!=Imem[i]) err++;
+ if (err)
+ printf("Function vec_ste [type int] ===> Error\n");
+ else
+ printf("Function vec_ste [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ b = 11;
+ Faux1.v = Fcons1;
+ vec_ste( Faux1.v, b, Fmem );
+ i = b/4;
+ if (Faux1.e[i]!=Fmem[i]) err++;
+ if (err)
+ printf("Function vec_ste [type float] ===> Error\n");
+ else
+ printf("Function vec_ste [type float] ===> OK\n");
+#endif
+
+#if 0
+/* Function vec_stl */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux1.v = UCcons1;
+ vec_stl( UCaux1.v, 0, UCmem );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]==UCmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_stl [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_stl [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Caux1.v = Ccons1;
+ vec_stl( Caux1.v, 0, Cmem );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]==Cmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_stl [type char] ===> Error\n");
+ else
+ printf("Function vec_stl [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = UScons3;
+ vec_stl( USaux1.v, 0, USmem );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]==USmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_stl [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_stl [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons1;
+ vec_stl( Saux1.v, 0, Smem );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]==Smem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_stl [type short] ===> Error\n");
+ else
+ printf("Function vec_stl [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = UIcons1;
+ vec_stl( UIaux1.v, 0, UImem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]==UImem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_stl [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_stl [type unsigned int] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = Icons1;
+ vec_stl( Iaux1.v, 0, Imem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]==Imem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_stl [type int] ===> Error\n");
+ else
+ printf("Function vec_stl [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = Fcons1;
+ vec_stl( Faux1.v, 0, Fmem );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]==Fmem[i]);
+ }
+ if (Iaux!=1) err++;
+
+ if (err)
+ printf("Function vec_stl [type float] ===> Error\n");
+ else
+ printf("Function vec_stl [type float] ===> OK\n");
+#endif
+#endif // #if 0
+
+ /* Free dynamic vector variables */
+ free_vec( UCmem );
+ free_vec( Cmem );
+ free_vec( USmem );
+ free_vec( Smem );
+ free_vec( UImem );
+ free_vec( Imem );
+#if defined TEST_FLOATS
+ free_vec( Fmem );
+#endif
+
+ return 0;
+}
+
+
+
+
+int part4( )
+{
+ TvecChar Caux1, Caux2, Caux3;//, Caux4;
+ TvecUChar UCaux1, UCaux2, UCaux3;//, UCaux4;
+ TvecShort Saux1, Saux2, Saux3;//, Saux4;
+ TvecUShort USaux1, USaux2, USaux3;//, USaux4;
+ TvecInt Iaux1, Iaux2, Iaux3;//, Iaux4;
+ TvecUInt UIaux1, UIaux2, UIaux3;//, UIaux4;
+#if defined TEST_FLOATS
+ TvecFloat Faux1, Faux2, Faux3;//, Faux4;
+#endif
+
+ int i, err, j;//, b, bAux;
+// signed int Ivec1, Ivec2, Ivec3;
+// signed short *Svec1;
+// unsigned int *UIvec1;
+// unsigned short *USvec1;
+// unsigned char *UCvec1;
+#if defined TEST_FLOATS
+// float *Fvec1;
+#endif
+
+ /* For saturated rutines */
+ long long int LLaux;
+
+#if defined TEST_FLOATS
+ float Faux;
+#endif
+ signed int Iaux;//, I1, I2;
+ unsigned int UIaux;//, UI1, UI2;
+ signed short Saux;
+ unsigned short USaux;
+ signed char Caux;
+ unsigned char UCaux;
+
+/*
+ union
+ {
+ float f;
+ signed int si;
+ unsigned int ui;
+ signed short ss[2];
+ unsigned short us[2];
+ signed char sc[4];
+ unsigned char uc[4];
+ } INTunion1, INTunion2;
+
+ union
+ {
+ signed short ss;
+ unsigned short us;
+ signed char sc[2];
+ unsigned char uc[2];
+ } SHOunion1, SHOunion2;
+*/
+
+#if defined (GCC_COMPILER)
+ vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127};
+ vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+ vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
+ vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3};
+ vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000};
+ vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767};
+ vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3};
+ vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1};
+ vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4};
+ vector signed int Icons1 = (vector signed int){-4, -1, 1, 4};
+ vector signed int Icons2 = (vector signed int){1, 1, 1, 1};
+ vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF};
+ vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1};
+ vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1};
+ vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2};
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999};
+ vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0};
+ vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0};
+#endif
+
+#elif defined (MAC_COMPILER) || defined(XLC_COMPILER)
+ vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+ vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127);
+ vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
+ vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+ vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3);
+ vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000);
+ vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767);
+ vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3);
+ vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1);
+ vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4);
+ vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4);
+ vector signed int Icons2 = (vector signed int)(1, 1, 1, 1);
+ vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF);
+ vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1);
+ vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1);
+ vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2);
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999);
+ vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0);
+ vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0);
+#endif
+
+#endif
+
+
+/* Function vec_sub */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_sub( Ccons1, Ccons2 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons2;
+ for( i=0; i< 16; i++ )
+ {
+ Caux = Caux2.e[i] - Caux3.e[i];
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sub [type char] ===> Error\n");
+ else
+ printf("Function vec_sub [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_sub( UCcons1, UCcons2 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons2;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux2.e[i] - UCaux3.e[i];
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sub [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sub [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_sub( Scons1, Scons2 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons2;
+ for( i=0; i< 8; i++ )
+ {
+ Saux = Saux2.e[i] - Saux3.e[i];
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sub [type short] ===> Error\n");
+ else
+ printf("Function vec_sub [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_sub( UScons1, UScons2 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons2;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = USaux2.e[i] - USaux3.e[i];
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sub [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_sub [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_sub( Icons1, Icons2 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i] - Iaux3.e[i];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sub [type integer] ===> Error\n");
+ else
+ printf("Function vec_sub [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_sub( UIcons1, UIcons2 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = UIaux2.e[i] - UIaux3.e[i];
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sub [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_sub [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = vec_sub( Fcons1, Fcons2 );
+ Faux2.v = Fcons1;
+ Faux3.v = Fcons2;
+ for( i=0; i< 4; i++ )
+ {
+ Faux = Faux2.e[i] - Faux3.e[i];
+ if (Faux1.e[i] != Faux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sub [type float] ===> Error\n");
+ else
+ printf("Function vec_sub [type float] ===> OK\n");
+#endif
+
+/* Function vec_subc */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UIaux1.v = vec_subc( UIcons2, UIcons3 );
+ UIaux2.v = UIcons2;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ if (UIaux3.e[i]>UIaux2.e[i])
+ {
+ if (UIaux1.e[i] != 0)
+ err++;
+ }
+ else
+ {
+ if (UIaux1.e[i] != 1)
+ err++;
+ }
+ }
+ if (err)
+ printf("Function vec_subc [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_subc [type unsigned int] ===> OK\n");
+
+/* Function vec_subs */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = vec_subs( Ccons1, Ccons3 );
+ Caux2.v = Ccons1;
+ Caux3.v = Ccons3;
+ for( i=0; i< 16; i++ )
+ {
+ Caux = (signed char)Caux2.e[i]-Caux3.e[i];
+ if ((Caux2.e[i]>=0)&&(Caux3.e[i]<0))
+ {
+ if (Caux< Caux2.e[i])
+ Caux=0x7F;
+ }
+ else if ((Caux2.e[i]<0)&&(Caux3.e[i]>0))
+ {
+ if (Caux> Caux2.e[i])
+ Caux=0x80;
+ }
+ if (Caux1.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_subs [type char] ===> Error\n");
+ else
+ printf("Function vec_subs [type char] ===> OK\n");
+
+ err = 0;
+ UCaux1.v = vec_subs( UCcons1, UCcons3 );
+ UCaux2.v = UCcons1;
+ UCaux3.v = UCcons3;
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = (unsigned char)(UCaux2.e[i]-UCaux3.e[i]);
+ if (UCaux> UCaux2.e[i])
+ UCaux=0;
+ if (UCaux1.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_subs [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_subs [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = vec_subs( Scons1, Scons3 );
+ Saux2.v = Scons1;
+ Saux3.v = Scons3;
+ for( i=0; i< 8; i++ )
+ {
+ Saux = (signed short)(Saux2.e[i] - Saux3.e[i]);
+ if ((Saux2.e[i]>=0)&&(Saux3.e[i]<0))
+ {
+ if (Saux< Saux2.e[i])
+ Saux=0x7FFF;
+ }
+ else if ((Saux2.e[i]<0)&&(Saux3.e[i]>0))
+ {
+ if (Saux> Saux2.e[i])
+ Saux=0x8000;
+ }
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_subs [type short] ===> Error\n");
+ else
+ printf("Function vec_subs [type short] ===> OK\n");
+
+ err = 0;
+ USaux1.v = vec_subs( UScons1, UScons3 );
+ USaux2.v = UScons1;
+ USaux3.v = UScons3;
+ for( i=0; i< 8; i++ )
+ {
+ USaux = (unsigned short)(USaux2.e[i] - USaux3.e[i]);
+ if (USaux> USaux2.e[i])
+ USaux=0x0;
+ if (USaux1.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_subs [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_subs [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+ Iaux1.v = vec_subs( Icons1, Icons3 );
+ Iaux2.v = Icons1;
+ Iaux3.v = Icons3;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = (signed int)(Iaux2.e[i] - Iaux3.e[i]);
+ if ((Iaux2.e[i]>=0)&&(Iaux3.e[i]<0))
+ {
+ if (Iaux< Iaux2.e[i])
+ Iaux=0x7FFFFFFF;
+ }
+ else if ((Iaux2.e[i]<0)&&(Iaux3.e[i]>0))
+ {
+ if (Iaux> Iaux2.e[i])
+ {
+ printf("%d > %d\n", Iaux, Iaux2.e[i]);
+ Iaux=0x80000000;
+ }
+ }
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_subs [type integer] ===> Error\n");
+ else
+ printf("Function vec_subs [type integer] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_subs( UIcons1, UIcons3 );
+ UIaux2.v = UIcons1;
+ UIaux3.v = UIcons3;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = (unsigned int)(UIaux2.e[i] - UIaux3.e[i]);
+ if (UIaux> UIaux2.e[i])
+ UIaux=0x0;
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_subs [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_subs [type unsigned int] ===> OK\n");
+
+/* Function vec_sum4s */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Iaux1.v = vec_sum4s( Ccons2, Icons2 );
+ Caux1.v = Ccons2;
+ Iaux2.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i];
+ for( j=0; j< 4; j++ )
+ Iaux = Iaux + Caux1.e[4*i+j];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sum4s [type char] ===> Error\n");
+ else
+ printf("Function vec_sum4s [type char] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = vec_sum4s( UCcons2, UIcons2 );
+ UCaux1.v = UCcons2;
+ UIaux2.v = UIcons2;
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = UIaux2.e[i];
+ for( j=0; j< 4; j++ )
+ UIaux = UIaux + UCaux1.e[4*i+j];
+ if (UIaux1.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sum4s [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_sum4s [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = vec_sum4s( Scons2, Icons2 );
+ Saux1.v = Scons2;
+ Iaux2.v = Icons2;
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux2.e[i];
+ for( j=0; j< 2; j++ )
+ Iaux = Iaux + Saux1.e[2*i+j];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_sum4s [type short] ===> Error\n");
+ else
+ printf("Function vec_sum4s [type short] ===> OK\n");
+
+/* Function vec_sum2s */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons3;
+ Iaux3.v = vec_sum2s( Iaux1.v, Iaux2.v );
+ for( i=0; i< 2; i++ )
+ {
+ LLaux = (long long int) Iaux1.e[2*i] + Iaux1.e[(2*i)+1] + Iaux2.e[(2*i)+1];
+ if (LLaux > INT_MAX)
+ {
+ Iaux=0x7FFFFFFF; /* INT_MAX */
+ }
+ else if (LLaux < INT_MIN)
+ {
+ Iaux=0x80000000; /* INT_MIN */
+ }
+ else Iaux = (signed int) LLaux;
+
+ if ((Iaux3.e[2*i] != 0) || (Iaux3.e[(2*i)+1] != Iaux))
+ err++;
+ }
+ if (err)
+ printf("Function vec_sum2s [type integer] ===> Error\n");
+ else
+ printf("Function vec_sum2s [type integer] ===> OK\n");
+
+/* Function vec_sums */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+
+ /* Not saturated test */
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons3;
+ Iaux3.v = vec_sums( Iaux1.v, Iaux2.v );
+
+ LLaux = (long long int) Iaux1.e[0] + Iaux1.e[1] + Iaux1.e[2] + Iaux1.e[3] + Iaux2.e[3];
+ if (LLaux > INT_MAX)
+ {
+ Iaux=0x7FFFFFFF; /* INT_MAX */
+ }
+ else if (LLaux < INT_MIN)
+ {
+ Iaux=0x80000000; /* INT_MIN */
+ }
+ else Iaux = (signed int) LLaux;
+
+ if ((Iaux3.e[0] != 0) || (Iaux3.e[1] != 0) || (Iaux3.e[2] != 0) ||
+ (Iaux3.e[3] != Iaux))
+ err++;
+
+ /* Saturated test */
+ Iaux1.v = Icons2;
+ Iaux2.v = Icons3;
+ Iaux3.v = vec_sums( Iaux1.v, Iaux2.v );
+
+ LLaux = (long long int) Iaux1.e[0] + Iaux1.e[1] + Iaux1.e[2] + Iaux1.e[3] + Iaux2.e[3];
+ if (LLaux > INT_MAX)
+ {
+ Iaux=0x7FFFFFFF; /* INT_MAX */
+ }
+ else if (LLaux < INT_MIN)
+ {
+ Iaux=0x80000000; /* INT_MIN */
+ }
+ else Iaux = (signed int) LLaux;
+
+ if ((Iaux3.e[0] != 0) || (Iaux3.e[1] != 0) || (Iaux3.e[2] != 0) ||
+ (Iaux3.e[3] != Iaux))
+ err++;
+
+ if (err)
+ printf("Function vec_sums [type integer] ===> Error\n");
+ else
+ printf("Function vec_sums [type integer] ===> OK\n");
+
+#if defined TEST_FLOATS
+/* Function vec_trunc */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = Fcons1;
+ Faux2.v = vec_trunc( Faux1.v );
+ for( i=0; i< 4; i++ )
+ {
+ Faux = truncf(Faux1.e[i]);
+ if (Faux2.e[i] != Faux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_trunc [type float] ===> Error\n");
+ else
+ printf("Function vec_trunc [type float] ===> OK\n");
+#endif
+
+/* Function vec_unpackh */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = Ccons1;
+ Saux1.v = vec_unpackh( Caux1.v );
+ for ( i=0; i< 8; i++ )
+ {
+ Saux = (signed short)Caux1.e[i];
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+
+ if (err)
+ printf("Function vec_unpackh [type short-char] ===> Error\n");
+ else
+ printf("Function vec_unpackh [type short-char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons3;
+ Iaux1.v = vec_unpackh( Saux1.v );
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = (signed int)Saux1.e[i];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+
+ if (err)
+ printf("Function vec_unpackh [type int-short] ===> Error\n");
+ else
+ printf("Function vec_unpackh [type int-short] ===> OK\n");
+
+/* Function vec_unpackl */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v = Ccons3;
+ Saux1.v = vec_unpackl( Caux1.v );
+ for ( i=0; i< 8; i++ )
+ {
+ Saux = (signed short)Caux1.e[i+8];
+ if (Saux1.e[i] != Saux)
+ err++;
+ }
+
+ if (err)
+ printf("Function vec_unpackl [type short-char] ===> Error\n");
+ else
+ printf("Function vec_unpackl [type short-char] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons1;
+ Iaux1.v = vec_unpackl( Saux1.v );
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = (signed int)Saux1.e[i+4];
+ if (Iaux1.e[i] != Iaux)
+ err++;
+ }
+
+ if (err)
+ printf("Function vec_unpackl [type int-short] ===> Error\n");
+ else
+ printf("Function vec_unpackl [type int-short] ===> OK\n");
+
+/* Function vec_xor */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux1.v = UCcons1;
+ UCaux2.v = UCcons3;
+ UCaux3.v = vec_xor( UCaux1.v, UCaux2.v );
+ for( i=0; i< 16; i++ )
+ {
+ UCaux = UCaux1.e[i] ^ UCaux2.e[i];
+ if (UCaux3.e[i] != UCaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_xor [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_xor [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Caux1.v = Ccons1;
+ Caux2.v = Ccons3;
+ Caux3.v = vec_xor( Caux1.v, Caux2.v );
+ for( i=0; i< 16; i++ )
+ {
+ Caux = Caux1.e[i] ^ Caux2.e[i];
+ if (Caux3.e[i] != Caux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_xor [type char] ===> Error\n");
+ else
+ printf("Function vec_xor [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = UScons1;
+ USaux2.v = UScons3;
+ USaux3.v = vec_xor( USaux1.v, USaux2.v );
+ for( i=0; i< 8; i++ )
+ {
+ USaux = USaux1.e[i] ^ USaux2.e[i];
+ if (USaux3.e[i] != USaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_xor [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_xor [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons1;
+ Saux2.v = Scons3;
+ Saux3.v = vec_xor( Saux1.v, Saux2.v );
+ for( i=0; i< 8; i++ )
+ {
+ Saux = Saux1.e[i] ^ Saux2.e[i];
+ if (Saux3.e[i] != Saux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_xor [type short] ===> Error\n");
+ else
+ printf("Function vec_xor [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = UIcons1;
+ UIaux2.v = UIcons3;
+ UIaux3.v = vec_xor( UIaux1.v, UIaux2.v );
+ for( i=0; i< 4; i++ )
+ {
+ UIaux = UIaux1.e[i] ^ UIaux2.e[i];
+ if (UIaux3.e[i] != UIaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_xor [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_xor [type unsigned int] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons3;
+ Iaux3.v = vec_xor( Iaux1.v, Iaux2.v );
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux1.e[i] ^ Iaux2.e[i];
+ if (Iaux3.e[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_xor [type int] ===> Error\n");
+ else
+ printf("Function vec_xor [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = Fcons1;
+ Faux2.v = Fcons3;
+ Faux3.v = vec_xor( Faux1.v, Faux2.v );
+ for( i=0; i< 4; i++ )
+ {
+ Iaux = Faux1.i[i] ^ Faux2.i[i];
+
+ if (Faux3.i[i] != Iaux)
+ err++;
+ }
+ if (err)
+ printf("Function vec_xor [type float] ===> Error\n");
+ else
+ printf("Function vec_xor [type float] ===> OK\n");
+#endif
+
+ return 0;
+}
+
+
+
+
+int part5()
+{
+ TvecChar Caux1, Caux2;//, Caux3, Caux4;
+ TvecUChar UCaux1, UCaux2;//, UCaux3, UCaux4;
+ TvecShort Saux1, Saux2;//, Saux3, Saux4;
+ TvecUShort USaux1, USaux2;//, USaux3, USaux4;
+ TvecInt Iaux1, Iaux2;//, Iaux3, Iaux4;
+ TvecUInt UIaux1, UIaux2;//, UIaux3, UIaux4;
+#if defined TEST_FLOATS
+ TvecFloat Faux1, Faux2;//, Faux3, Faux4;
+#endif
+
+ int i, err, /*j,*/ b, bAux;
+// signed int Ivec1, Ivec2, Ivec3;
+// signed short *Svec1;
+// unsigned int *UIvec1;
+// unsigned short *USvec1;
+// unsigned char *UCvec1;
+#if defined TEST_FLOATS
+// float *Fvec1;
+#endif
+
+ /* For saturated rutines */
+// long long int LLaux;
+
+#if defined TEST_FLOATS
+// float Faux;
+#endif
+ signed int Iaux, I1;//, I2;
+// unsigned int UIaux, UI1, UI2;
+// signed short Saux;
+// unsigned short USaux;
+// signed char Caux;
+// unsigned char UCaux;
+
+/*
+ union
+ {
+ float f;
+ signed int si;
+ unsigned int ui;
+ signed short ss[2];
+ unsigned short us[2];
+ signed char sc[4];
+ unsigned char uc[4];
+ } INTunion1, INTunion2;
+
+ union
+ {
+ signed short ss;
+ unsigned short us;
+ signed char sc[2];
+ unsigned char uc[2];
+ } SHOunion1, SHOunion2;
+*/
+
+
+#if defined (GCC_COMPILER)
+ vector signed char Ccons1 = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector signed char Ccons2 = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ vector signed char Ccons3 = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127};
+ vector unsigned char UCcons1 = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7};
+ vector unsigned char UCcons2 = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+ vector unsigned char UCcons3 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
+ vector signed short Scons1 = (vector signed short){-4, -3, -2, -1, 0, 1, 2, 3};
+ vector signed short Scons2 = (vector signed short){-32768, 10000, 1, 1, 1, 1, -10000, -10000};
+ vector signed short Scons3 = (vector signed short){-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767};
+ vector unsigned short UScons1 = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3};
+ vector unsigned short UScons2 = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1};
+ vector unsigned short UScons3 = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4};
+ vector signed int Icons1 = (vector signed int){-4, -1, 1, 4};
+ vector signed int Icons2 = (vector signed int){1, 1, 1, 1};
+ vector signed int Icons3 = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF};
+ vector unsigned int UIcons1 = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1};
+ vector unsigned int UIcons2 = (vector unsigned int){1, 1, 1, 1};
+ vector unsigned int UIcons3 = (vector unsigned int){1, 2, 1, 2};
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float){-1.5, 1.0, 0.5, -3.999};
+ vector float Fcons2 = (vector float){1.0, 1.0, 1.0, 1.0};
+ vector float Fcons3 = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0};
+#endif
+
+#elif defined (MAC_COMPILER) || defined(XLC_COMPILER)
+ vector signed char Ccons1 = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector signed char Ccons2 = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+ vector signed char Ccons3 = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127);
+ vector unsigned char UCcons1 = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7);
+ vector unsigned char UCcons2 = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
+ vector unsigned char UCcons3 = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+ vector signed short Scons1 = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3);
+ vector signed short Scons2 = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000);
+ vector signed short Scons3 = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767);
+ vector unsigned short UScons1 = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3);
+ vector unsigned short UScons2 = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1);
+ vector unsigned short UScons3 = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4);
+ vector signed int Icons1 = (vector signed int)(-4, -1, 1, 4);
+ vector signed int Icons2 = (vector signed int)(1, 1, 1, 1);
+ vector signed int Icons3 = (vector signed int)(0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF);
+ vector unsigned int UIcons1 = (vector unsigned int)(0xFFFFFFFE, 0xFFFFFFFF, 0, 1);
+ vector unsigned int UIcons2 = (vector unsigned int)(1, 1, 1, 1);
+ vector unsigned int UIcons3 = (vector unsigned int)(1, 2, 1, 2);
+
+#if defined TEST_FLOATS
+ vector float Fcons1 = (vector float)(-1.5, 1.0, 0.5, -3.999);
+ vector float Fcons2 = (vector float)(1.0, 1.0, 1.0, 1.0);
+ vector float Fcons3 = (vector float)(100000000000.0, 1.0, -1.0, -1234567890.0);
+#endif
+
+#endif
+
+
+/* Function vec_all_eq */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux1.v = UCcons1;
+ UCaux2.v = UCcons1;
+ I1 = vec_all_eq( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]==UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UCaux1.v = UCcons2;
+ UCaux2.v = UCcons3;
+ I1 = vec_all_eq( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]==UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_eq [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_all_eq [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Caux1.v = Ccons1;
+ Caux2.v = Ccons1;
+ I1 = vec_all_eq( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]==Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Caux1.v = Ccons1;
+ Caux2.v = Ccons2;
+ I1 = vec_all_eq( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]==Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_eq [type char] ===> Error\n");
+ else
+ printf("Function vec_all_eq [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = UScons1;
+ USaux2.v = UScons1;
+ I1 = vec_all_eq( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]==USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ USaux1.v = UScons2;
+ USaux2.v = UScons3;
+ I1 = vec_all_eq( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]==USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_eq [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_all_eq [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons1;
+ Saux2.v = Scons1;
+ I1 = vec_all_eq( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]==Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Saux1.v = Scons2;
+ Saux2.v = Scons3;
+ I1 = vec_all_eq( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]==Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_eq [type short] ===> Error\n");
+ else
+ printf("Function vec_all_eq [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = UIcons1;
+ UIaux2.v = UIcons1;
+ I1 = vec_all_eq( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]==UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UIaux1.v = UIcons2;
+ UIaux2.v = UIcons3;
+ I1 = vec_all_eq( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]==UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_eq [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_all_eq [type unsigned int] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons1;
+ I1 = vec_all_eq( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]==Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons2;
+ I1 = vec_all_eq( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]==Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_eq [type int] ===> Error\n");
+ else
+ printf("Function vec_all_eq [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = Fcons1;
+ Faux2.v = Fcons1;
+ I1 = vec_all_eq( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]==Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Faux1.v = Fcons1;
+ Faux2.v = Fcons2;
+ I1 = vec_all_eq( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]==Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_eq [type float] ===> Error\n");
+ else
+ printf("Function vec_all_eq [type float] ===> OK\n");
+#endif
+
+/* Function vec_all_ge */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux1.v = UCcons2;
+ UCaux2.v = UCcons2;
+ I1 = vec_all_ge( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]>=UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UCaux1.v = UCcons2;
+ UCaux2.v = UCcons3;
+ I1 = vec_all_ge( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]>=UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_ge [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_all_ge [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Caux1.v = Ccons2;
+ Caux2.v = Ccons2;
+ I1 = vec_all_ge( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]>=Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Caux1.v = Ccons2;
+ Caux2.v = Ccons3;
+ I1 = vec_all_ge( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]>=Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_ge [type char] ===> Error\n");
+ else
+ printf("Function vec_all_ge [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = UScons3;
+ USaux2.v = UScons2;
+ I1 = vec_all_ge( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]>=USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ I1 = vec_all_ge( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]>=USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_ge [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_all_ge [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons1;
+ Saux2.v = Scons1;
+ I1 = vec_all_ge( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]>=Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Saux1.v = Scons2;
+ Saux2.v = Scons3;
+ I1 = vec_all_ge( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]>=Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_ge [type short] ===> Error\n");
+ else
+ printf("Function vec_all_ge [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = UIcons3;
+ UIaux2.v = UIcons2;
+ I1 = vec_all_ge( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]>=UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UIaux1.v = UIcons1;
+ UIaux2.v = UIcons2;
+ I1 = vec_all_ge( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]>=UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_ge [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_all_ge [type unsigned int] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = Icons2;
+ Iaux2.v = Icons2;
+ I1 = vec_all_ge( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]>=Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Iaux1.v = Icons2;
+ Iaux2.v = Icons1;
+ I1 = vec_all_ge( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]>=Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_ge [type int] ===> Error\n");
+ else
+ printf("Function vec_all_ge [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = Fcons2;
+ Faux2.v = Fcons1;
+ I1 = vec_all_ge( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]>=Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Faux1.v = Fcons2;
+ Faux2.v = Fcons3;
+ I1 = vec_all_ge( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]>=Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_ge [type float] ===> Error\n");
+ else
+ printf("Function vec_all_ge [type float] ===> OK\n");
+#endif
+
+/* Function vec_all_gt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ UCaux1.v = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 2, 3, 4, 5, 6, 7, 8, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 2, 3, 4, 5, 6, 7, 8, 9);
+# endif
+ UCaux2.v = UCcons2;
+ I1 = vec_all_gt( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]>UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UCaux1.v = UCcons2;
+ UCaux2.v = UCcons3;
+ I1 = vec_all_gt( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]>UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_gt [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_all_gt [type unsigned char] ===> OK\n");
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Caux1.v = (vector signed char){9, 8, 7, 6, 5, 4, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v = (vector signed char)(9, 8, 7, 6, 5, 4, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+# endif
+ Caux2.v = Ccons2;
+ I1 = vec_all_gt( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]>Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Caux1.v = Ccons2;
+ Caux2.v = Ccons3;
+ I1 = vec_all_gt( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]>Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_gt [type char] ===> Error\n");
+ else
+ printf("Function vec_all_gt [type char] ===> OK\n");
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ USaux1.v = (vector unsigned short){65532, 65533, 65534, 65535, 2, 3, 4, 5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v = (vector unsigned short)(65532, 65533, 65534, 65535, 2, 3, 4, 5);
+# endif
+ USaux2.v = UScons2;
+ I1 = vec_all_gt( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]>USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ I1 = vec_all_gt( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]>USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_gt [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_all_gt [type unsigned short] ===> OK\n");
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Saux1.v = (vector signed short){4, 3, 2, 1, 2, 3, 4, 5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v = (vector signed short)(4, 3, 2, 1, 2, 3, 4, 5);
+# endif
+ Saux2.v = Scons1;
+ I1 = vec_all_gt( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]>Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Saux1.v = Scons2;
+ Saux2.v = Scons3;
+ I1 = vec_all_gt( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]>Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_gt [type short] ===> Error\n");
+ else
+ printf("Function vec_all_gt [type short] ===> OK\n");
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UIaux1.v = (vector unsigned int){3, 2, 3, 2};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v = (vector unsigned int)(3, 2, 3, 2);
+# endif
+ UIaux2.v = UIcons2;
+ I1 = vec_all_gt( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]>UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UIaux1.v = UIcons1;
+ UIaux2.v = UIcons2;
+ I1 = vec_all_gt( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]>UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_gt [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_all_gt [type unsigned int] ===> OK\n");
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Iaux1.v = (vector signed int){4, 10, 10, 4};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v = (vector signed int)(4, 10, 10, 4);
+# endif
+ Iaux2.v = Icons2;
+ I1 = vec_all_gt( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]>Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Iaux1.v = Icons2;
+ Iaux2.v = Icons1;
+ I1 = vec_all_gt( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]>Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_gt [type int] ===> Error\n");
+ else
+ printf("Function vec_all_gt [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float){100000000000.0, 12.0, 12.0, 1234567890.0};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float)(100000000000.0, 12.0, 12.0, 1234567890.0);
+# endif
+ Faux2.v = Fcons1;
+ I1 = vec_all_gt( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]>Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Faux1.v = Fcons2;
+ Faux2.v = Fcons3;
+ I1 = vec_all_gt( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]>Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_gt [type float] ===> Error\n");
+ else
+ printf("Function vec_all_gt [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_all_in */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = Fcons1;
+ Faux2.v = Fcons2;
+ I1 = vec_all_in( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && ((Faux1.e[i]<=Faux2.e[i]) && (Faux1.e[i]>=-Faux2.e[i]));
+ }
+ if (I1 != Iaux) err++;
+
+ Faux1.v = Fcons2;
+# if defined (GCC_COMPILER)
+ Faux2.v = (vector float){100000000000.0, 1.0, 1.0, 1234567890.0};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux2.v = (vector float)(100000000000.0, 1.0, 1.0, 1234567890.0);
+# endif
+ I1 = vec_all_in( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && ((Faux1.e[i]<=Faux2.e[i]) && (Faux1.e[i]>=-Faux2.e[i]));
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_in [type float] ===> Error\n");
+ else
+ printf("Function vec_all_in [type float] ===> OK\n");
+#endif
+
+/* Function vec_all_le */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux1.v = UCcons2;
+ UCaux2.v = UCcons3;
+ I1 = vec_all_le( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]<=UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UCaux1.v = UCcons1;
+ UCaux2.v = UCcons2;
+ I1 = vec_all_le( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]<=UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_le [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_all_le [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Caux1.v = Ccons2;
+ Caux2.v = Ccons2;
+ I1 = vec_all_le( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]<=Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Caux1.v = Ccons2;
+ Caux2.v = Ccons3;
+ I1 = vec_all_le( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]<=Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_le [type char] ===> Error\n");
+ else
+ printf("Function vec_all_le [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = UScons2;
+ USaux2.v = UScons3;
+ I1 = vec_all_le( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]<=USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ USaux1.v = UScons1;
+ USaux2.v = UScons2;
+ I1 = vec_all_le( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]<=USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_le [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_all_le [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons1;
+ Saux2.v = Scons1;
+ I1 = vec_all_le( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]<=Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Saux1.v = Scons2;
+ Saux2.v = Scons3;
+ I1 = vec_all_le( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]<=Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_le [type short] ===> Error\n");
+ else
+ printf("Function vec_all_le [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = UIcons2;
+ UIaux2.v = UIcons3;
+ I1 = vec_all_le( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]<=UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UIaux1.v = UIcons1;
+ UIaux2.v = UIcons2;
+ I1 = vec_all_le( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]<=UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_le [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_all_le [type unsigned int] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = Icons2;
+ Iaux2.v = Icons2;
+ I1 = vec_all_le( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]<=Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons2;
+ I1 = vec_all_le( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]<=Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_le [type int] ===> Error\n");
+ else
+ printf("Function vec_all_le [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = Fcons1;
+ Faux2.v = Fcons2;
+ I1 = vec_all_le( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]<=Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Faux1.v = Fcons2;
+ Faux2.v = Fcons3;
+ I1 = vec_all_le( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]<=Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_le [type float] ===> Error\n");
+ else
+ printf("Function vec_all_le [type float] ===> OK\n");
+#endif
+
+/* Function vec_all_lt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ UCaux1.v = UCcons2;
+# if defined (GCC_COMPILER)
+ UCaux2.v = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 2, 3, 4, 5, 6, 7, 8, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 2, 3, 4, 5, 6, 7, 8, 9);
+# endif
+ I1 = vec_all_lt( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]<UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UCaux1.v = UCcons3;
+ UCaux2.v = UCcons2;
+ I1 = vec_all_lt( UCaux1.v, UCaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (UCaux1.e[i]<UCaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_lt [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_all_lt [type unsigned char] ===> OK\n");
+
+ err = 0;
+ Caux1.v = Ccons2;
+# if defined (GCC_COMPILER)
+ Caux2.v = (vector signed char){9, 8, 7, 6, 5, 4, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux2.v = (vector signed char)(9, 8, 7, 6, 5, 4, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+# endif
+ I1 = vec_all_lt( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]<Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Caux1.v = Ccons3;
+ Caux2.v = Ccons2;
+ I1 = vec_all_lt( Caux1.v, Caux2.v );
+ Iaux = 1;
+ for ( i=0; i< 16; i++ )
+ {
+ Iaux = Iaux && (Caux1.e[i]<Caux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_lt [type char] ===> Error\n");
+ else
+ printf("Function vec_all_lt [type char] ===> OK\n");
+
+ err = 0;
+ USaux1.v = UScons2;
+# if defined (GCC_COMPILER)
+ USaux2.v = (vector unsigned short){65532, 65533, 65534, 65535, 2, 3, 4, 5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux2.v = (vector unsigned short)(65532, 65533, 65534, 65535, 2, 3, 4, 5);
+# endif
+ I1 = vec_all_lt( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]<USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ USaux1.v = UScons2;
+ USaux2.v = UScons1;
+ I1 = vec_all_lt( USaux1.v, USaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (USaux1.e[i]<USaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_lt [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_all_lt [type unsigned short] ===> OK\n");
+
+ err = 0;
+ Saux1.v = Scons1;
+# if defined (GCC_COMPILER)
+ Saux2.v = (vector signed short){4, 3, 2, 1, 2, 3, 4, 5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux2.v = (vector signed short)(4, 3, 2, 1, 2, 3, 4, 5);
+# endif
+ I1 = vec_all_lt( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]<Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Saux1.v = Scons3;
+ Saux2.v = Scons2;
+ I1 = vec_all_lt( Saux1.v, Saux2.v );
+ Iaux = 1;
+ for ( i=0; i< 8; i++ )
+ {
+ Iaux = Iaux && (Saux1.e[i]<Saux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_lt [type short] ===> Error\n");
+ else
+ printf("Function vec_all_lt [type short] ===> OK\n");
+
+ err = 0;
+ UIaux1.v = UIcons2;
+# if defined (GCC_COMPILER)
+ UIaux2.v = (vector unsigned int){3, 2, 3, 2};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux2.v = (vector unsigned int)(3, 2, 3, 2);
+# endif
+ I1 = vec_all_lt( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]<UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ UIaux1.v = UIcons2;
+ UIaux2.v = UIcons1;
+ I1 = vec_all_lt( UIaux1.v, UIaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (UIaux1.e[i]<UIaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_lt [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_all_lt [type unsigned int] ===> OK\n");
+
+ err = 0;
+ Iaux1.v = Icons2;
+# if defined (GCC_COMPILER)
+ Iaux2.v = (vector signed int){4, 10, 10, 4};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux2.v = (vector signed int)(4, 10, 10, 4);
+# endif
+ I1 = vec_all_lt( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]<Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Iaux1.v = Icons1;
+ Iaux2.v = Icons2;
+ I1 = vec_all_lt( Iaux1.v, Iaux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Iaux1.e[i]<Iaux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_lt [type int] ===> Error\n");
+ else
+ printf("Function vec_all_lt [type int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+ Faux1.v = Fcons1;
+# if defined (GCC_COMPILER)
+ Faux2.v = (vector float){100000000000.0, 12.0, 12.0, 1234567890.0};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux2.v = (vector float)(100000000000.0, 12.0, 12.0, 1234567890.0);
+# endif
+ I1 = vec_all_lt( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]<Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ Faux1.v = Fcons3;
+ Faux2.v = Fcons2;
+ I1 = vec_all_lt( Faux1.v, Faux2.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (Faux1.e[i]<Faux2.e[i]);
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_lt [type float] ===> Error\n");
+ else
+ printf("Function vec_all_lt [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_all_nan */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float){NAN, NAN, NAN, NAN};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float)(NAN, NAN, NAN, NAN);
+# endif
+ I1 = vec_all_nan( Faux1.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (isnan(Faux1.e[i]));
+ }
+ if (I1 != Iaux) err++;
+
+ Faux1.v = Fcons1;
+ I1 = vec_all_nan( Faux1.v );
+ Iaux = 1;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux && (isnan(Faux1.e[i]));
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_all_nan [type float] ===> Error\n");
+ else
+ printf("Function vec_all_nan [type float] ===> OK\n");
+#endif
+
+/* Function vec_all_ne */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Caux1.v = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v = (vector signed char){-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -8};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v = (vector signed char)(-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -8);
+# endif
+ b = vec_all_ne (Caux1.v, Caux2.v);
+ bAux = 1;
+ for (i=0; i<16; i++)
+ bAux = bAux && (Caux1.e[i]!=Caux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Caux1.v = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v = (vector signed char){-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 4, 6, 7, -8};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v = (vector signed char)(-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 4, 6, 7, -8);
+# endif
+ b = vec_all_ne (Caux1.v, Caux2.v);
+ bAux= 1;
+ for (i=0; i<16; i++)
+ bAux= bAux && (Caux1.e[i]!=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux1.v = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v = (vector signed char){-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 4, 6, 7, -8};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v = (vector signed char)(-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 4, 6, 7, -8);
+# endif
+ b = vec_all_ne (Caux1.v, Caux2.v);
+ bAux = 1;
+ for (i=0; i<16; i++)
+ bAux = bAux && (Caux1.e[i] != Caux2.e[i]);
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_ne [type char] ===> Error\n");
+ else
+ printf("Function vec_all_ne [type char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UCaux1.v = (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v = (vector unsigned char){201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v = (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v = (vector unsigned char)(201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200);
+# endif
+
+ b = vec_all_ne (UCaux1.v, UCaux2.v);
+ bAux= 1;
+ for (i=0; i<16; i++)
+ bAux= bAux && (UCaux1.e[i]!=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux1.v = (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v = (vector unsigned char){201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v = (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v = (vector unsigned char)(201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200);
+# endif
+ b = vec_all_ne (UCaux1.v, UCaux2.v);
+ bAux = 1;
+ for (i=0; i<16; i++)
+ bAux = bAux && (UCaux1.e[i] != UCaux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ UCaux1.v = (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v = (vector unsigned char){201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v = (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v = (vector unsigned char)(201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17,200);
+# endif
+ b = vec_all_ne (UCaux1.v, UCaux2.v);
+ bAux = 1;
+ for (i=0; i<16; i++)
+ bAux = bAux && (UCaux1.e[i] != UCaux2.e[i]);
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_ne [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_all_ne [type unsigned char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Saux1.v = (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v = (vector signed short){-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v = (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v = (vector signed short)(-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800);
+# endif
+ b = vec_all_ne (Saux1.v, Saux2.v);
+ bAux = 1;
+ for (i=0; i<8; i++)
+ bAux = bAux && (Saux1.e[i] != Saux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Saux1.v = (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v = (vector signed short){-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v = (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v = (vector signed short)(-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800);
+# endif
+ b = vec_all_ne (Saux1.v, Saux2.v);
+ bAux = 1;
+ for (i=0; i<8; i++)
+ bAux = bAux && (Saux1.e[i] != Saux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Saux1.v = (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v = (vector signed short){-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v = (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v = (vector signed short)(-3700, -3600, -3500, 0, 3300, 3200, 3100,-3800);
+# endif
+ b = vec_all_ne (Saux1.v, Saux2.v);
+ bAux = 1;
+ for (i=0; i<8; i++)
+ bAux = bAux && (Saux1.e[i] != Saux2.e[i]);
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_ne [type short] ===> Error\n");
+ else
+ printf("Function vec_all_ne [type short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ USaux1.v = (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v = (vector unsigned short){47000, 46000, 45000, 0, 3300, 3200, 3100,48000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v = (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v = (vector unsigned short)(47000, 46000, 45000, 0, 3300, 3200, 3100,48000);
+# endif
+ b = vec_all_ne (USaux1.v, USaux2.v);
+ bAux = 1;
+ for (i=0; i<8; i++)
+ bAux = bAux && (USaux1.e[i] != USaux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ USaux1.v = (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v = (vector unsigned short){47000, 46000, 45000, 0, 3300, 3200, 3100,48000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v = (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v = (vector unsigned short)(47000, 46000, 45000, 0, 3300, 3200, 3100,48000);
+# endif
+ b = vec_all_ne (USaux1.v, USaux2.v);
+ bAux = 1;
+ for (i=0; i<8; i++)
+ bAux = bAux && (USaux1.e[i] != USaux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ USaux1.v = (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v = (vector unsigned short){47000, 46000, 45000, 0, 3300, 3200, 3100,48000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v = (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v = (vector unsigned short)(47000, 46000, 45000, 0, 3300, 3200, 3100,48000);
+# endif
+ b = vec_all_ne (USaux1.v, USaux2.v);
+ bAux = 1;
+ for (i=0; i<8; i++)
+ bAux = bAux && (USaux1.e[i] != USaux2.e[i]);
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_ne [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_all_ne [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Iaux1.v = (vector signed int){-1003800, -1003700, 0, 1003300};
+ Iaux2.v = (vector signed int){-1003700, 0, 1003300,-1003800};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v = (vector signed int)(-1003800, -1003700, 0, 1003300);
+ Iaux2.v = (vector signed int)(-1003700, 0, 1003300,-1003800);
+# endif
+ b = vec_all_ne (Iaux1.v, Iaux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (Iaux1.e[i] != Iaux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Iaux1.v = (vector signed int){-1003800, -1003700, 0, 1003300};
+ Iaux2.v = (vector signed int){-1003700, 0, 1003300,-1003800};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v = (vector signed int)(-1003800, -1003700, 0, 1003300);
+ Iaux2.v = (vector signed int)(-1003700, 0, 1003300,-1003800);
+# endif
+ b = vec_all_ne (Iaux1.v, Iaux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (Iaux1.e[i] != Iaux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0, 1003300};
+ Iaux2.v= (vector signed int){-1003700, 0, 1003300,-1003800};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0, 1003300);
+ Iaux2.v= (vector signed int)(-1003700, 0, 1003300,-1003800);
+# endif
+ b = vec_all_ne (Iaux1.v, Iaux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (Iaux1.e[i] != Iaux2.e[i]);
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_ne [type int] ===> Error\n");
+ else
+ printf("Function vec_all_ne [type int] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UIaux1.v = (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v = (vector unsigned int){ 12345678, 0, 1,0xFFFFF000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v = (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v = (vector unsigned int)( 12345678, 0, 1,0xFFFFF000);
+# endif
+ b = vec_all_ne (UIaux1.v, UIaux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (UIaux1.e[i] != UIaux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ UIaux1.v = (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v = (vector unsigned int){ 12345678, 0, 1,0xFFFFF000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v = (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v = (vector unsigned int)( 12345678, 0, 1,0xFFFFF000);
+# endif
+ b = vec_all_ne (UIaux1.v, UIaux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (UIaux1.e[i] != UIaux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ UIaux1.v = (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v = (vector unsigned int){ 12345678, 0, 1,0xFFFFF000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v = (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v = (vector unsigned int)( 12345678, 0, 1,0xFFFFF000);
+# endif
+ b = vec_all_ne (UIaux1.v, UIaux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (UIaux1.e[i] != UIaux2.e[i]);
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_ne [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_all_ne [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 1.0, 0.5, -3.999, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 1.0, 0.5, -3.999, -1.5);
+# endif
+ b = vec_all_ne (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (Faux1.e[i] != Faux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 1.0, 0.5, -3.999, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 1.0, 0.5, -3.999, -1.5);
+# endif
+ b = vec_all_ne (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (Faux1.e[i] != Faux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 1.0, 0.5, -3.999, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 1.0, 0.5, -3.999, -1.5);
+# endif
+ b = vec_all_ne (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (Faux1.e[i] != Faux2.e[i]);
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_ne [type float] ===> Error\n");
+ else
+ printf("Function vec_all_ne [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_all_nge */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_nge (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ (Faux1.e[i] < Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_nge (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ (Faux1.e[i] < Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_nge (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ (Faux1.e[i] < Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_nge (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ (Faux1.e[i] < Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_nge [type float] ===> Error\n");
+ else
+ printf("Function vec_all_nge [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_all_ngt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_ngt (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] > Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_ngt (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] > Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_ngt (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] > Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_ngt (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] > Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_ngt [type float] ===> Error\n");
+ else
+ printf("Function vec_all_ngt [type float] ===> OK\n");
+#endif
+
+#if defined TEST_FLOATS
+/* Function vec_all_nle */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+# endif
+ b = vec_all_nle (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] <= Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+# endif
+ b = vec_all_nle (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] <= Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+# endif
+ b = vec_all_nle (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] <=Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v = (vector float) {-1.5, 1.0, NAN, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v = (vector float) (-1.5, 1.0, NAN, -3.999);
+# endif
+ b = vec_all_nle (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] <= Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_nle [type float] ===> Error\n");
+ else
+ printf("Function vec_all_nle [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_all_nlt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+# endif
+ b = vec_all_nlt (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] < Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v = (vector float) {-1.5, 5.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v = (vector float) (-1.5, 5.0, 0.5, -3.999);
+# endif
+ b = vec_all_nlt (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] < Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v = (vector float) {-1.5, 1.0, 0.55, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v = (vector float) (-1.5, 1.0, 0.55, -3.999);
+# endif
+ b = vec_all_nlt (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] < Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v = (vector float) {-1.5, 1.0, NAN, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v = (vector float) (-1.5, 1.0, NAN, -3.999);
+# endif
+ b = vec_all_nlt (Faux1.v, Faux2.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux &&
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i] < Faux2.e[i]));
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_nlt [type float] ===> Error\n");
+ else
+ printf("Function vec_all_nlt [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_all_numeric */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_all_numeric (Faux1.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && !isnan(Faux1.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {0.0, 3.5, 0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (0.0, 3.5, 0.5, -1.5);
+# endif
+ b = vec_all_numeric (Faux1.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && !isnan(Faux1.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {0.0, 3.5, NAN, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (0.0, 3.5, NAN, -1.5);
+# endif
+ b = vec_all_numeric (Faux1.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && !isnan(Faux1.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {NAN, NAN, NAN, NAN};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (NAN, NAN, NAN, NAN);
+# endif
+ b = vec_all_numeric (Faux1.v);
+ bAux = 1;
+ for (i=0; i<4; i++)
+ bAux = bAux && !isnan(Faux1.e[i]);
+ if (bAux != b) err = 1;
+
+ if (err)
+ printf("Function vec_all_numeric [type float] ===> Error\n");
+ else
+ printf("Function vec_all_numeric [type float] ===> OK\n");
+#endif
+
+/* Function vec_any_eq */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Caux1.v= Ccons1;
+ Caux2.v= Ccons3;
+ b= vec_any_eq (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]==Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ Caux1.v= Ccons1;
+ Caux2.v= Ccons2;
+ b= vec_any_eq (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]==Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_eq [type char] ===> Error\n");
+ else
+ printf("Function vec_any_eq [type char] ===> OK\n");
+
+
+ err = 0;
+ UCaux1.v= UCcons1;
+ UCaux2.v= UCcons3;
+ b= vec_any_eq (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]==UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ UCaux1.v= UCcons1;
+ UCaux2.v= UCcons2;
+ b= vec_any_eq (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]==UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_eq [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_any_eq [type unsigned char] ===> OK\n");
+
+
+ err = 0;
+ Saux1.v= Scons1;
+ Saux2.v= Scons3;
+ b= vec_any_eq (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]==Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ Saux1.v= Scons1;
+ Saux2.v= Scons2;
+ b= vec_any_eq (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]==Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_eq [type short] ===> Error\n");
+ else
+ printf("Function vec_any_eq [type short] ===> OK\n");
+
+
+ err = 0;
+ USaux1.v= UScons1;
+ USaux2.v= UScons3;
+ b= vec_any_eq (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]==USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ USaux1.v= UScons1;
+ USaux2.v= UScons2;
+ b= vec_any_eq (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]==USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_eq [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_any_eq [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+ Iaux1.v= Icons1;
+ Iaux2.v= Icons3;
+ b= vec_any_eq (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]==Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ Iaux1.v= Icons1;
+ Iaux2.v= Icons2;
+ b= vec_any_eq (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]==Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_eq [type int] ===> Error\n");
+ else
+ printf("Function vec_any_eq [type int] ===> OK\n");
+
+
+ err = 0;
+ UIaux1.v= UIcons1;
+ UIaux2.v= UIcons3;
+ b= vec_any_eq (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]==UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ UIaux1.v= UIcons1;
+ UIaux2.v= UIcons2;
+ b= vec_any_eq (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]==UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_eq [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_any_eq [type unsigned int] ===> OK\n");
+
+
+#if defined TEST_FLOATS
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b = vec_any_eq (Faux1.v, Faux2.v);
+ bAux = 0;
+ for (i=0; i<4; i++)
+ bAux = bAux || (Faux1.e[i] == Faux2.e[i]);
+ if (bAux != b) err = 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v = (vector float) { 0.0, 3.5, 0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v = (vector float) ( 0.0, 3.5, 0.5, -1.5);
+# endif
+ b= vec_any_eq (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]==Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_eq [type float] ===> Error\n");
+ else
+ printf("Function vec_any_eq [type float] ===> OK\n");
+#endif
+
+/* Function vec_any_ge */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_ge (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]>=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_ge (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]>=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_ge (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]>=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ge [type char] ===> Error\n");
+ else
+ printf("Function vec_any_ge [type char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_ge (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]>=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_ge (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]>=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_ge (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]>=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ge [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_any_ge [type unsigned char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_ge (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]>=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_ge (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]>=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_ge (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]>=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ge [type short] ===> Error\n");
+ else
+ printf("Function vec_any_ge [type short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_ge (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]>=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_ge (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]>=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_ge (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]>=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ge [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_any_ge [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_ge (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]>=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_ge (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]>=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_ge (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]>=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ge [type int] ===> Error\n");
+ else
+ printf("Function vec_any_ge [type int] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_ge (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]>=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_ge (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]>=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_ge (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]>=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ge [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_any_ge [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_ge (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]>=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.5, -1.5);
+# endif
+ b= vec_any_ge (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]>=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5,-0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5,-0.5, -1.5);
+# endif
+ b= vec_any_ge (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]>=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ge [type float] ===> Error\n");
+ else
+ printf("Function vec_any_ge [type float] ===> OK\n");
+#endif
+
+/* Function vec_any_gt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_gt (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]>Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_gt (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]>Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_gt (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]>Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_gt [type char] ===> Error\n");
+ else
+ printf("Function vec_any_gt [type char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_gt (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]>UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_gt (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]>UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_gt (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]>UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_gt [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_any_gt [type unsigned char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_gt (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]>Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_gt (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]>Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_gt (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]>Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_gt [type short] ===> Error\n");
+ else
+ printf("Function vec_any_gt [type short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_gt (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]>USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_gt (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]>USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_gt (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]>USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_gt [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_any_gt [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_gt (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]>Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_gt (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]>Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_gt (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]>Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_gt [type int] ===> Error\n");
+ else
+ printf("Function vec_any_gt [type int] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_gt (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]>UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_gt (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]>UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_gt (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]>UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_gt [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_any_gt [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_gt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]>Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.5, -1.5);
+# endif
+ b= vec_any_gt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]>Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5,-0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5,-0.5, -1.5);
+# endif
+ b= vec_any_gt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]>Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_gt [type float] ===> Error\n");
+ else
+ printf("Function vec_any_gt [type float] ===> OK\n");
+#endif
+
+
+/* Function vec_any_le */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_le (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]<=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_le (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]<=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_le (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]<=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_le [type char] ===> Error\n");
+ else
+ printf("Function vec_any_le [type char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_le (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]<=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_le (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]<=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_le (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]<=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_le [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_any_le [type unsigned char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_le (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]<=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_le (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]<=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_le (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]<=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_le [type short] ===> Error\n");
+ else
+ printf("Function vec_any_le [type short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_le (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]<=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_le (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]<=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_le (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]<=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_le [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_any_le [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_le (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]<=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_le (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]<=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_le (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]<=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_le [type int] ===> Error\n");
+ else
+ printf("Function vec_any_le [type int] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux1.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_le (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]<=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux1.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_le (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]<=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux1.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_le (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]<=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_le [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_any_le [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_le (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]<=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux1.v= (vector float) { 0.0, 3.5, 0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.5, -1.5);
+# endif
+ b= vec_any_le (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]<=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux1.v= (vector float) { 0.0, 3.5,-0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux1.v= (vector float) ( 0.0, 3.5,-0.5, -1.5);
+# endif
+ b= vec_any_le (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]<=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_le [type float] ===> Error\n");
+ else
+ printf("Function vec_any_le [type float] ===> OK\n");
+#endif
+
+
+/* Function vec_any_lt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_lt (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]<Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_lt (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]<Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux1.v= (vector signed char){ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux1.v= (vector signed char)( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
+# endif
+ b= vec_any_lt (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]<Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_lt [type char] ===> Error\n");
+ else
+ printf("Function vec_any_lt [type char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_lt (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]<UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_lt (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]<UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux1.v= (vector unsigned char){250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux1.v= (vector unsigned char)(250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250);
+# endif
+ b= vec_any_lt (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]<UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_lt [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_any_lt [type unsigned char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_lt (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]<Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_lt (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]<Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux1.v= (vector signed short){ 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux1.v= (vector signed short)( 9000, 9000, 9000, 9000, 9000, 9000, 9000, 9000);
+# endif
+ b= vec_any_lt (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]<Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_lt [type short] ===> Error\n");
+ else
+ printf("Function vec_any_lt [type short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_lt (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]<USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_lt (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]<USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux1.v= (vector unsigned short){59000, 59000, 59000, 59000,59000, 9000, 9000, 9000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux1.v= (vector unsigned short)(59000, 59000, 59000, 59000,59000, 9000, 9000, 9000);
+# endif
+ b= vec_any_lt (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]<USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_lt [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_any_lt [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_lt (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]<Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_lt (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]<Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux1.v= (vector signed int){ 9000000, 9000000, 9000000,9000000};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux1.v= (vector signed int)( 9000000, 9000000, 9000000,9000000);
+# endif
+ b= vec_any_lt (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]<Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_lt [type int] ===> Error\n");
+ else
+ printf("Function vec_any_lt [type int] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux1.v= (vector unsigned int){0xFFFFFFF0, 20000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 20000000, 9, 9);
+# endif
+ b= vec_any_lt (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]<UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux1.v= (vector unsigned int){0xFFFFFFF0, 12345678, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 12345678, 9, 9);
+# endif
+ b= vec_any_lt (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]<UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux1.v= (vector unsigned int){0xFFFFFFF0, 10000000, 9, 9};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux1.v= (vector unsigned int)(0xFFFFFFF0, 10000000, 9, 9);
+# endif
+ b= vec_any_lt (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]<UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_lt [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_any_lt [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_lt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]<Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux1.v= (vector float) { 0.0, 3.5, 0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.5, -1.5);
+# endif
+ b= vec_any_lt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]<Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux1.v= (vector float) { 0.0, 3.5,-0.5, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux1.v= (vector float) ( 0.0, 3.5,-0.5, -1.5);
+# endif
+ b= vec_any_lt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]<Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_lt [type float] ===> Error\n");
+ else
+ printf("Function vec_any_lt [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_any_nan */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_nan (Faux1.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, NAN, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, NAN, -1.5);
+# endif
+ b= vec_any_nan (Faux1.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { NAN, 3.5, NAN, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( NAN, 3.5, NAN, -1.5);
+# endif
+ b= vec_any_nan (Faux1.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_nan [type float] ===> Error\n");
+ else
+ printf("Function vec_any_nan [type float] ===> OK\n");
+#endif
+
+
+/* Function vec_any_ne */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+# endif
+ b= vec_any_ne (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]!=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+# endif
+ b= vec_any_ne (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]!=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Caux1.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+ Caux2.v= (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Caux1.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+ Caux2.v= (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
+# endif
+ b= vec_any_ne (Caux1.v, Caux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (Caux1.e[i]!=Caux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ne [type char] ===> Error\n");
+ else
+ printf("Function vec_any_ne [type char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+# endif
+ b= vec_any_ne (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]!=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){200, 201, 206, 205, 0, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 205, 0, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+# endif
+ b= vec_any_ne (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]!=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UCaux1.v= (vector unsigned char){200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+ UCaux2.v= (vector unsigned char){200, 201, 206, 206, 0, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UCaux1.v= (vector unsigned char)(200, 201, 206, 205, 204, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+ UCaux2.v= (vector unsigned char)(200, 201, 206, 206, 0, 203, 202, 201, 200, 101, 102, 13, 14, 15, 16, 17);
+# endif
+ b= vec_any_ne (UCaux1.v, UCaux2.v);
+ bAux= 0;
+ for (i=0; i<16; i++)
+ bAux= bAux || (UCaux1.e[i]!=UCaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ne [type unsigned char] ===> Error\n");
+ else
+ printf("Function vec_any_ne [type unsigned char] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+# endif
+ b= vec_any_ne (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]!=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){-3800, 3700, -3600, -3500, 0, 3300, 3200, 3100};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)(-3800, 3700, -3600, -3500, 0, 3300, 3200, 3100);
+# endif
+ b= vec_any_ne (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]!=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Saux1.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100};
+ Saux2.v= (vector signed short){-3800, -3700, -3600, -3500, 0, 3300, 3100, 3100};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Saux1.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3200, 3100);
+ Saux2.v= (vector signed short)(-3800, -3700, -3600, -3500, 0, 3300, 3100, 3100);
+# endif
+ b= vec_any_ne (Saux1.v, Saux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (Saux1.e[i]!=Saux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ne [type short] ===> Error\n");
+ else
+ printf("Function vec_any_ne [type short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+# endif
+ b= vec_any_ne (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]!=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3100, 3100};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3100, 3100);
+# endif
+ b= vec_any_ne (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]!=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ USaux1.v= (vector unsigned short){48000, 47000, 46000, 45000, 0, 3300, 3200, 3100};
+ USaux2.v= (vector unsigned short){48000, 47000, 46000, 0, 0, 3300, 3100, 3100};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ USaux1.v= (vector unsigned short)(48000, 47000, 46000, 45000, 0, 3300, 3200, 3100);
+ USaux2.v= (vector unsigned short)(48000, 47000, 46000, 0, 0, 3300, 3100, 3100);
+# endif
+ b= vec_any_ne (USaux1.v, USaux2.v);
+ bAux= 0;
+ for (i=0; i<8; i++)
+ bAux= bAux || (USaux1.e[i]!=USaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ne [type unsigned short] ===> Error\n");
+ else
+ printf("Function vec_any_ne [type unsigned short] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){-1003800, -1003700, 0,1003300};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+# endif
+ b= vec_any_ne (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]!=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){-1003800, -1003700, 0,1113300};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)(-1003800, -1003700, 0,1113300);
+# endif
+ b= vec_any_ne (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]!=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Iaux1.v= (vector signed int){-1003800, -1003700, 0,1003300};
+ Iaux2.v= (vector signed int){-1003800, 10, 0,1113300};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Iaux1.v= (vector signed int)(-1003800, -1003700, 0,1003300);
+ Iaux2.v= (vector signed int)(-1003800, 10, 0,1113300);
+# endif
+ b= vec_any_ne (Iaux1.v, Iaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Iaux1.e[i]!=Iaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ne [type int] ===> Error\n");
+ else
+ printf("Function vec_any_ne [type int] ===> OK\n");
+
+
+ err = 0;
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+# endif
+ b= vec_any_ne (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]!=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFF000, 12345678, 5, 1};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFF000, 12345678, 5, 1);
+# endif
+ b= vec_any_ne (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]!=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ UIaux1.v= (vector unsigned int){0xFFFFF000, 12345678, 0, 1};
+ UIaux2.v= (vector unsigned int){0xFFFFFFF0, 12345678, 5, 1};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ UIaux1.v= (vector unsigned int)(0xFFFFF000, 12345678, 0, 1);
+ UIaux2.v= (vector unsigned int)(0xFFFFFFF0, 12345678, 5, 1);
+# endif
+ b= vec_any_ne (UIaux1.v, UIaux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (UIaux1.e[i]!=UIaux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ne [type unsigned int] ===> Error\n");
+ else
+ printf("Function vec_any_ne [type unsigned int] ===> OK\n");
+
+#if defined TEST_FLOATS
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+# endif
+ b= vec_any_ne (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]!=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.998};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.998);
+# endif
+ b= vec_any_ne (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]!=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) {-1.5, 0.0, 0.5, -3.998};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) (-1.5, 0.0, 0.5, -3.998);
+# endif
+ b= vec_any_ne (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || (Faux1.e[i]!=Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ne [type float] ===> Error\n");
+ else
+ printf("Function vec_any_ne [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_any_nge */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+# endif
+ b= vec_any_nge (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ (Faux1.e[i]<Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v= (vector float) {-1.5, 1.0, 0.55, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v= (vector float) (-1.5, 1.0, 0.55, -3.999);
+# endif
+ b= vec_any_nge (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ (Faux1.e[i]<Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v= (vector float) {-1.5, 5.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v= (vector float) (-1.5, 5.0, 0.5, -3.999);
+# endif
+ b= vec_any_nge (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ (Faux1.e[i]<Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v= (vector float) {-1.5, 1.0, NAN, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v= (vector float) (-1.5, 1.0, NAN, -3.999);
+# endif
+ b= vec_any_nge (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ (Faux1.e[i]<Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_nge [type float] ===> Error\n");
+ else
+ printf("Function vec_any_nge [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_any_ngt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+# endif
+ b= vec_any_ngt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ !(Faux1.e[i]>Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v= (vector float) {-1.5, 1.0, 0.55, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v= (vector float) (-1.5, 1.0, 0.55, -3.999);
+# endif
+ b= vec_any_ngt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ !(Faux1.e[i]>Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v= (vector float) {-1.5, 5.0, 0.5, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v= (vector float) (-1.5, 5.0, 0.5, -3.999);
+# endif
+ b= vec_any_ngt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ !(Faux1.e[i]>Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+ Faux2.v= (vector float) {-1.5, 1.0, NAN, -3.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+ Faux2.v= (vector float) (-1.5, 1.0, NAN, -3.999);
+# endif
+ b= vec_any_ngt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || isnan(Faux1.e[i]) || isnan(Faux2.e[i]) ||
+ !(Faux1.e[i]>Faux2.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_ngt [type float] ===> Error\n");
+ else
+ printf("Function vec_any_ngt [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_any_nle */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_nle (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux ||
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<=Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.55, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.55, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_nle (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux ||
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<=Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 5.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 5.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_nle (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux ||
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<=Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, NAN, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, NAN, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_nle (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux ||
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<=Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_nle [type float] ===> Error\n");
+ else
+ printf("Function vec_any_nle [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_any_nlt */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_nlt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux ||
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, 0.55, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, 0.55, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_all_nlt (Faux1.v, Faux2.v);
+ b= vec_any_nlt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux ||
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 5.0, 0.5, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 5.0, 0.5, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_nlt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux ||
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) {-1.5, 1.0, NAN, -3.999};
+ Faux2.v= (vector float) { 0.0, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) (-1.5, 1.0, NAN, -3.999);
+ Faux2.v= (vector float) ( 0.0, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_nlt (Faux1.v, Faux2.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux ||
+ (isnan(Faux1.e[i]) || isnan(Faux2.e[i]) || !(Faux1.e[i]<Faux2.e[i]));
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_nlt [type float] ===> Error\n");
+ else
+ printf("Function vec_any_nlt [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_any_numeric */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { NAN, NAN, NAN, NAN};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( NAN, NAN, NAN, NAN);
+# endif
+ b= vec_any_numeric (Faux1.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || !isnan(Faux1.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { NAN, 3.5, NAN, NAN};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( NAN, 3.5, NAN, NAN);
+# endif
+ b= vec_any_numeric (Faux1.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || !isnan(Faux1.e[i]);
+ if (bAux!=b) err= 1;
+
+# if defined (GCC_COMPILER)
+ Faux1.v= (vector float) { -1.5, 3.5, 0.55, -1.5};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v= (vector float) ( -1.5, 3.5, 0.55, -1.5);
+# endif
+ b= vec_any_numeric (Faux1.v);
+ bAux= 0;
+ for (i=0; i<4; i++)
+ bAux= bAux || !isnan(Faux1.e[i]);
+ if (bAux!=b) err= 1;
+
+ if (err)
+ printf("Function vec_any_numeric [type float] ===> Error\n");
+ else
+ printf("Function vec_any_numeric [type float] ===> OK\n");
+#endif
+
+
+#if defined TEST_FLOATS
+/* Function vec_any_out */
+ printf("\n:::::::::::::::::::::::::::::::::::::::\n");
+ err = 0;
+ Faux1.v = Fcons1;
+ Faux2.v = Fcons2;
+ I1 = vec_any_out( Faux1.v, Faux2.v );
+ Iaux = 0;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux || ((isnan(Faux1.e[i])) || (isnan(Faux2.e[i])) ||
+ (Faux1.e[i]>Faux2.e[i]) || (Faux1.e[i]<-Faux2.e[i]));
+ }
+ if (I1 != Iaux) err++;
+
+# if defined (GCC_COMPILER)
+ Faux1.v = (vector float){-0.5, 1.0, 0, -0.999};
+# elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
+ Faux1.v = (vector float)(-0.5, 1.0, 0, -0.999);
+# endif
+ Faux2.v = Fcons2;
+ I1 = vec_any_out( Faux1.v, Faux2.v );
+ Iaux = 0;
+ for ( i=0; i< 4; i++ )
+ {
+ Iaux = Iaux || ((isnan(Faux1.e[i])) || (isnan(Faux2.e[i])) ||
+ (Faux1.e[i]>Faux2.e[i]) || (Faux1.e[i]<-Faux2.e[i]));
+ }
+ if (I1 != Iaux) err++;
+
+ if (err)
+ printf("Function vec_any_out [type float] ===> Error\n");
+ else
+ printf("Function vec_any_out [type float] ===> OK\n");
+#endif
+
+ return 0;
+}
projects / thirdparty / valgrind.git / commitdiff
