mono/mini/basic-vectors.cs

   1 using System;
   2 using System.Numerics;
   3 using System.Runtime.CompilerServices;
   4
   5 /*
   6  * Tests for the SIMD intrinsics in the System.Numerics.Vectors assembly.
   7  */
   8 public class VectorTests {
   9
  10 #if !MOBILE
  11         public static int Main (string[] args) {
  12                 return TestDriver.RunTests (typeof (VectorTests), args);
  13         }
  14 #endif
  15
  16         //
  17         // Vector2 tests
  18         //
  19
  20         public static int test_0_vector2_ctor_1 () {
  21                 var v = new Vector2 (1.0f);
  22
  23                 if (v.X != 1.0f)
  24                         return 1;
  25                 if (v.Y != 1.0f)
  26                         return 2;
  27                 return 0;
  28         }
  29
  30         public static int test_0_vector2_ctor_2 () {
  31                 var v = new Vector2 (1.0f, 2.0f);
  32
  33                 if (v.X != 1.0f)
  34                         return 1;
  35                 if (v.Y != 2.0f)
  36                         return 2;
  37                 return 0;
  38         }
  39
  40         [MethodImplAttribute (MethodImplOptions.NoInlining)]
  41         public static bool vector2_equals (Vector2 v1, Vector2 v2) {
  42                 // cmpeqps+pmovmskb
  43                 return v1.Equals (v2);
  44         }
  45
  46         public static int test_0_vector2_equals () {
  47                 var v1 = new Vector2 (1.0f, 2.0f);
  48                 var v2 = new Vector2 (2.0f, 2.0f);
  49
  50                 if (vector2_equals (v1, v2))
  51                         return 1;
  52                 if (!vector2_equals (v1, v1))
  53                         return 2;
  54                 return 0;
  55         }
  56
  57         [MethodImplAttribute (MethodImplOptions.NoInlining)]
  58         public static float vector2_dot (Vector2 v1, Vector2 v2) {
  59                 return Vector2.Dot (v1, v2);
  60         }
  61
  62         public static int test_0_vector2_dot () {
  63                 var v1 = new Vector2 (1.0f, 1.0f);
  64                 var v2 = new Vector2 (2.0f, 2.0f);
  65
  66                 float f = vector2_dot (v1, v2);
  67                 if (f != 4.0f)
  68                         return 1;
  69                 f = vector2_dot (v1, v1);
  70                 if (f != 2.0f)
  71                         return 2;
  72                 return 0;
  73         }
  74
  75         [MethodImplAttribute (MethodImplOptions.NoInlining)]
  76         public static Vector2 vector2_min (Vector2 v1, Vector2 v2) {
  77                 return Vector2.Min (v1, v2);
  78         }
  79
  80         public static int test_0_vector2_min () {
  81                 var v1 = new Vector2 (1.0f, 1.0f);
  82                 var v2 = new Vector2 (2.0f, 2.0f);
  83
  84                 var v3 = vector2_min (v1, v2);
  85                 if (v3.X != 1.0f || v3.Y != 1.0f)
  86                         return 1;
  87                 v3 = vector2_min (v2, v2);
  88                 if (v3.X != 2.0f || v3.Y != 2.0f)
  89                         return 2;
  90                 return 0;
  91         }
  92
  93         [MethodImplAttribute (MethodImplOptions.NoInlining)]
  94         public static Vector2 vector2_max (Vector2 v1, Vector2 v2) {
  95                 return Vector2.Max (v1, v2);
  96         }
  97
  98         public static int test_0_vector2_max () {
  99                 var v1 = new Vector2 (1.0f, 1.0f);
 100                 var v2 = new Vector2 (2.0f, 2.0f);
 101
 102                 var v3 = vector2_max (v1, v2);
 103                 if (v3.X != 2.0f || v3.Y != 2.0f)
 104                         return 1;
 105                 v3 = vector2_min (v1, v1);
 106                 if (v3.X != 1.0f || v3.Y != 1.0f)
 107                         return 2;
 108                 return 0;
 109         }
 110
 111         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 112         public static Vector2 vector2_abs (Vector2 v1) {
 113                 return Vector2.Abs (v1);
 114         }
 115
 116         [Category ("!INTERPRETER")]
 117         public static int test_0_vector2_abs () {
 118                 var v1 = new Vector2 (-1.0f, -2.0f);
 119                 var v2 = new Vector2 (1.0f, 2.0f);
 120
 121                 var v3 = vector2_abs (v1);
 122                 if (v3.X != 1.0f || v3.Y != 2.0f)
 123                         return 1;
 124                 v3 = vector2_abs (v2);
 125                 if (v3.X != 1.0f || v3.Y != 2.0f)
 126                         return 2;
 127                 return 0;
 128         }
 129
 130         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 131         public static Vector2 vector2_sqrt (Vector2 v1) {
 132                 return Vector2.SquareRoot (v1);
 133         }
 134
 135         public static int test_0_vector2_sqrt () {
 136                 var v1 = new Vector2 (1.0f, 0.0f);
 137
 138                 var v3 = vector2_sqrt (v1);
 139                 if (v3.X != 1.0f || v3.Y != 0.0f)
 140                         return 1;
 141                 return 0;
 142         }
 143
 144         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 145         public static Vector2 vector2_add (Vector2 v1, Vector2 v2) {
 146                 return v1 + v2;
 147         }
 148
 149         public static int test_0_vector2_add () {
 150                 var v1 = new Vector2 (1.0f, 2.0f);
 151                 var v2 = new Vector2 (3.0f, 4.0f);
 152
 153                 var v3 = vector2_add (v1, v2);
 154                 if (v3.X != 4.0f || v3.Y != 6.0f)
 155                         return 1;
 156                 return 0;
 157         }
 158
 159         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 160         public static Vector2 vector2_sub (Vector2 v1, Vector2 v2) {
 161                 return v1 - v2;
 162         }
 163
 164         public static int test_0_vector2_sub () {
 165                 var v1 = new Vector2 (1.0f, 2.0f);
 166                 var v2 = new Vector2 (3.0f, 5.0f);
 167
 168                 var v3 = vector2_sub (v2, v1);
 169                 if (v3.X != 2.0f || v3.Y != 3.0f)
 170                         return 1;
 171                 return 0;
 172         }
 173
 174         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 175         public static Vector2 vector2_mul (Vector2 v1, Vector2 v2) {
 176                 return v1 * v2;
 177         }
 178
 179         public static int test_0_vector2_mul () {
 180                 var v1 = new Vector2 (1.0f, 2.0f);
 181                 var v2 = new Vector2 (3.0f, 5.0f);
 182
 183                 var v3 = vector2_mul (v2, v1);
 184                 if (v3.X != 3.0f || v3.Y != 10.0f)
 185                         return 1;
 186                 return 0;
 187         }
 188
 189         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 190         public static Vector2 vector2_mul_left (float v1, Vector2 v2) {
 191                 return v1 * v2;
 192         }
 193
 194         public static int test_0_vector2_mul_left () {
 195                 var v1 = new Vector2 (3.0f, 5.0f);
 196
 197                 var v3 = vector2_mul_left (2.0f, v1);
 198                 if (v3.X != 6.0f || v3.Y != 10.0f)
 199                         return 1;
 200                 return 0;
 201         }
 202
 203         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 204         public static Vector2 vector2_mul_right (Vector2 v1, float v2) {
 205                 return v1 * v2;
 206         }
 207
 208         public static int test_0_vector2_mul_right () {
 209                 var v1 = new Vector2 (3.0f, 5.0f);
 210
 211                 var v3 = vector2_mul_right (v1, 2.0f);
 212                 if (v3.X != 6.0f || v3.Y != 10.0f)
 213                         return 1;
 214                 return 0;
 215         }
 216
 217         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 218         public static Vector2 vector2_div (Vector2 v1, Vector2 v2) {
 219                 return v1 / v2;
 220         }
 221
 222         public static int test_0_vector2_div () {
 223                 var v1 = new Vector2 (9.0f, 10.0f);
 224                 var v2 = new Vector2 (3.0f, 5.0f);
 225
 226                 var v3 = vector2_div (v1, v2);
 227                 if (v3.X != 3.0f || v3.Y != 2.0f)
 228                         return 1;
 229                 return 0;
 230         }
 231
 232         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 233         public static Vector2 vector2_div_right (Vector2 v1, float v2) {
 234                 return v1 / v2;
 235         }
 236
 237         public static int test_0_vector2_div_right () {
 238                 var v1 = new Vector2 (9.0f, 15.0f);
 239
 240                 var v3 = vector2_div_right (v1, 3.0f);
 241                 if (v3.X != 3.0f || v3.Y != 5.0f)
 242                         return 1;
 243                 return 0;
 244         }
 245
 246         //
 247         // Vector4 tests
 248         //
 249
 250         public static int test_0_vector4_ctor_1 () {
 251                 var v = new Vector4 (1.0f);
 252
 253                 if (v.X != 1.0f)
 254                         return 1;
 255                 if (v.Y != 1.0f)
 256                         return 2;
 257                 if (v.Z != 1.0f)
 258                         return 3;
 259                 if (v.W != 1.0f)
 260                         return 4;
 261                 return 0;
 262         }
 263
 264         public static int test_0_vector4_ctor_2 () {
 265                 var v = new Vector4 (1.0f, 2.0f, 3.0f, 4.0f);
 266
 267                 if (v.X != 1.0f)
 268                         return 1;
 269                 if (v.Y != 2.0f)
 270                         return 2;
 271                 if (v.Z != 3.0f)
 272                         return 3;
 273                 if (v.W != 4.0f)
 274                         return 4;
 275                 return 0;
 276         }
 277
 278         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 279         public static bool vector4_equals (Vector4 v1, Vector4 v2) {
 280                 // cmpeqps+pmovmskb
 281                 return v1.Equals (v2);
 282         }
 283
 284         public static int test_0_vector4_equals () {
 285                 var v1 = new Vector4 (1.0f, 2.0f, 3.0f, 4.0f);
 286                 var v2 = new Vector4 (2.0f, 2.0f, 2.0f, 2.0f);
 287
 288                 if (vector4_equals (v1, v2))
 289                         return 1;
 290                 if (!vector4_equals (v1, v1))
 291                         return 2;
 292                 return 0;
 293         }
 294
 295         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 296         public static float vector4_dot (Vector4 v1, Vector4 v2) {
 297                 return Vector4.Dot (v1, v2);
 298         }
 299
 300         public static int test_0_vector4_dot () {
 301                 var v1 = new Vector4 (1.0f, 1.0f, 1.0f, 1.0f);
 302                 var v2 = new Vector4 (2.0f, 2.0f, 2.0f, 2.0f);
 303
 304                 float f = vector4_dot (v1, v2);
 305                 if (f != 8.0f)
 306                         return 1;
 307                 f = vector4_dot (v1, v1);
 308                 if (f != 4.0f)
 309                         return 2;
 310                 return 0;
 311         }
 312
 313         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 314         public static Vector4 vector4_min (Vector4 v1, Vector4 v2) {
 315                 return Vector4.Min (v1, v2);
 316         }
 317
 318         public static int test_0_vector4_min () {
 319                 var v1 = new Vector4 (1.0f, 2.0f, 3.0f, 4.0f);
 320                 var v2 = new Vector4 (5.0f, 6.0f, 7.0f, 8.0f);
 321
 322                 var v3 = vector4_min (v1, v2);
 323                 if (v3.X != 1.0f || v3.Y != 2.0f || v3.Z != 3.0f || v3.W != 4.0f)
 324                         return 1;
 325                 v3 = vector4_min (v2, v2);
 326                 if (v3.X != 5.0f || v3.Y != 6.0f || v3.Z != 7.0f || v3.W != 8.0f)
 327                         return 2;
 328                 return 0;
 329         }
 330
 331         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 332         public static Vector4 vector4_max (Vector4 v1, Vector4 v2) {
 333                 return Vector4.Max (v1, v2);
 334         }
 335
 336         public static int test_0_vector4_max () {
 337                 var v1 = new Vector4 (1.0f, 2.0f, 3.0f, 4.0f);
 338                 var v2 = new Vector4 (5.0f, 6.0f, 7.0f, 8.0f);
 339
 340                 var v3 = vector4_max (v1, v2);
 341                 if (v3.X != 5.0f || v3.Y != 6.0f || v3.Z != 7.0f || v3.W != 8.0f)
 342                         return 1;
 343                 v3 = vector4_max (v1, v1);
 344                 if (v3.X != 1.0f || v3.Y != 2.0f || v3.Z != 3.0f || v3.W != 4.0f)
 345                         return 2;
 346                 return 0;
 347         }
 348
 349         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 350         public static Vector4 vector4_abs (Vector4 v1) {
 351                 return Vector4.Abs (v1);
 352         }
 353
 354         [Category ("!INTERPRETER")]
 355         public static int test_0_vector4_abs () {
 356                 var v1 = new Vector4 (-1.0f, -2.0f, -3.0f, -4.0f);
 357                 var v2 = new Vector4 (1.0f, 2.0f, 3.0f, 4.0f);
 358
 359                 var v3 = vector4_abs (v1);
 360                 if (v3.X != 1.0f || v3.Y != 2.0f || v3.Z != 3.0f || v3.W != 4.0f)
 361                         return 1;
 362                 v3 = vector4_abs (v2);
 363                 if (v3.X != 1.0f || v3.Y != 2.0f || v3.Z != 3.0f || v3.W != 4.0f)
 364                         return 2;
 365                 return 0;
 366         }
 367
 368         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 369         public static Vector4 vector4_sqrt (Vector4 v1) {
 370                 return Vector4.SquareRoot (v1);
 371         }
 372
 373         public static int test_0_vector4_sqrt () {
 374                 var v1 = new Vector4 (1.0f, 0.0f, 1.0f, 0.0f);
 375
 376                 var v3 = vector4_sqrt (v1);
 377                 if (v3.X != 1.0f || v3.Y != 0.0f || v3.Z != 1.0f || v3.W != 0.0f)
 378                         return 1;
 379                 return 0;
 380         }
 381
 382         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 383         public static Vector4 vector4_add (Vector4 v1, Vector4 v2) {
 384                 return v1 + v2;
 385         }
 386
 387         public static int test_0_vector4_add () {
 388                 var v1 = new Vector4 (1.0f, 2.0f, 3.0f, 4.0f);
 389                 var v2 = new Vector4 (5.0f, 6.0f, 7.0f, 8.0f);
 390
 391                 var v3 = vector4_add (v1, v2);
 392                 if (v3.X != 6.0f || v3.Y != 8.0f || v3.Z != 10.0f || v3.W != 12.0f)
 393                         return 1;
 394                 return 0;
 395         }
 396
 397         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 398         public static Vector4 vector4_sub (Vector4 v1, Vector4 v2) {
 399                 return v1 - v2;
 400         }
 401
 402         public static int test_0_vector4_sub () {
 403                 var v1 = new Vector4 (1.0f, 2.0f, 3.0f, 4.0f);
 404                 var v2 = new Vector4 (3.0f, 5.0f, 7.0f, 9.0f);
 405
 406                 var v3 = vector4_sub (v2, v1);
 407                 if (v3.X != 2.0f || v3.Y != 3.0f || v3.Z != 4.0f || v3.W != 5.0f)
 408                         return 1;
 409                 return 0;
 410         }
 411
 412         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 413         public static Vector4 vector4_mul (Vector4 v1, Vector4 v2) {
 414                 return v1 * v2;
 415         }
 416
 417         public static int test_0_vector4_mul () {
 418                 var v1 = new Vector4 (1.0f, 2.0f, 3.0f, 4.0f);
 419                 var v2 = new Vector4 (3.0f, 5.0f, 6.0f, 7.0f);
 420
 421                 var v3 = vector4_mul (v2, v1);
 422                 if (v3.X != 3.0f || v3.Y != 10.0f || v3.Z != 18.0f || v3.W != 28.0f)
 423                         return 1;
 424                 return 0;
 425         }
 426
 427         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 428         public static Vector4 vector4_mul_left (float v1, Vector4 v2) {
 429                 return v1 * v2;
 430         }
 431
 432         public static int test_0_vector4_mul_left () {
 433                 var v1 = new Vector4 (3.0f, 5.0f, 6.0f, 7.0f);
 434
 435                 var v3 = vector4_mul_left (2.0f, v1);
 436                 if (v3.X != 6.0f || v3.Y != 10.0f || v3.Z != 12.0f || v3.W != 14.0f)
 437                         return 1;
 438                 return 0;
 439         }
 440
 441         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 442         public static Vector4 vector4_mul_right (Vector4 v1, float v2) {
 443                 return v1 * v2;
 444         }
 445
 446         public static int test_0_vector4_mul_right () {
 447                 var v1 = new Vector4 (3.0f, 5.0f, 6.0f, 7.0f);
 448
 449                 var v3 = vector4_mul_right (v1, 2.0f);
 450                 if (v3.X != 6.0f || v3.Y != 10.0f || v3.Z != 12.0f || v3.W != 14.0f)
 451                         return 1;
 452                 return 0;
 453         }
 454
 455         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 456         public static Vector4 vector4_div (Vector4 v1, Vector4 v2) {
 457                 return v1 / v2;
 458         }
 459
 460         public static int test_0_vector4_div () {
 461                 var v1 = new Vector4 (9.0f, 10.0f, 12.0f, 21.0f);
 462                 var v2 = new Vector4 (3.0f, 5.0f, 6.0f, 7.0f);
 463
 464                 var v3 = vector4_div (v1, v2);
 465                 if (v3.X != 3.0f || v3.Y != 2.0f || v3.Z != 2.0f || v3.W != 3.0f)
 466                         return 1;
 467                 return 0;
 468         }
 469
 470         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 471         public static Vector4 vector4_div_right (Vector4 v1, float v2) {
 472                 return v1 / v2;
 473         }
 474
 475         public static int test_0_vector4_div_right () {
 476                 var v1 = new Vector4 (9.0f, 15.0f, 21.0f, 30.0f);
 477
 478                 var v3 = vector4_div_right (v1, 3.0f);
 479                 if (v3.X != 3.0f || v3.Y != 5.0f || v3.Z != 7.0f || v3.W != 10.0f)
 480                         return 1;
 481                 return 0;
 482         }
 483
 484         public static int test_0_vector4_length () {
 485                 var v = new Vector4 (2.0f, 2.0f, 2.0f, 2.0f);
 486                 return v.Length () == 4.0f ? 0 : 1;
 487         }
 488
 489         //
 490         // Vector3 tests
 491         //
 492
 493         public static int test_0_vector3_ctor_1 () {
 494                 var v = new Vector3 (1.0f);
 495
 496                 if (v.X != 1.0f)
 497                         return 1;
 498                 if (v.Y != 1.0f)
 499                         return 2;
 500                 if (v.Z != 1.0f)
 501                         return 3;
 502                 return 0;
 503         }
 504
 505         public static int test_0_vector3_ctor_2 () {
 506                 var v = new Vector3 (1.0f, 2.0f, 3.0f);
 507
 508                 if (v.X != 1.0f)
 509                         return 1;
 510                 if (v.Y != 2.0f)
 511                         return 2;
 512                 if (v.Z != 3.0f)
 513                         return 3;
 514                 return 0;
 515         }
 516
 517         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 518         public static bool vector3_equals (Vector3 v1, Vector3 v2) {
 519                 // cmpeqps+pmovmskb
 520                 return v1.Equals (v2);
 521         }
 522
 523         public static int test_0_vector3_equals () {
 524                 var v1 = new Vector3 (1.0f, 2.0f, 3.0f);
 525                 var v2 = new Vector3 (2.0f, 2.0f, 2.0f);
 526
 527                 if (vector3_equals (v1, v2))
 528                         return 1;
 529                 if (!vector3_equals (v1, v1))
 530                         return 2;
 531                 return 0;
 532         }
 533
 534         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 535         public static float vector3_dot (Vector3 v1, Vector3 v2) {
 536                 return Vector3.Dot (v1, v2);
 537         }
 538
 539         public static int test_0_vector3_dot () {
 540                 var v1 = new Vector3 (1.0f, 1.0f, 1.0f);
 541                 var v2 = new Vector3 (2.0f, 2.0f, 2.0f);
 542
 543                 float f = vector3_dot (v1, v2);
 544                 if (f != 6.0f)
 545                         return 1;
 546                 f = vector3_dot (v1, v1);
 547                 if (f != 3.0f)
 548                         return 2;
 549                 return 0;
 550         }
 551
 552         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 553         public static Vector3 vector3_min (Vector3 v1, Vector3 v2) {
 554                 return Vector3.Min (v1, v2);
 555         }
 556
 557         public static int test_0_vector3_min () {
 558                 var v1 = new Vector3 (1.0f, 2.0f, 3.0f);
 559                 var v2 = new Vector3 (5.0f, 6.0f, 7.0f);
 560
 561                 var v3 = vector3_min (v1, v2);
 562                 if (v3.X != 1.0f || v3.Y != 2.0f || v3.Z != 3.0f)
 563                         return 1;
 564                 v3 = vector3_min (v2, v2);
 565                 if (v3.X != 5.0f || v3.Y != 6.0f || v3.Z != 7.0f)
 566                         return 2;
 567                 return 0;
 568         }
 569
 570         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 571         public static Vector3 vector3_max (Vector3 v1, Vector3 v2) {
 572                 return Vector3.Max (v1, v2);
 573         }
 574
 575         public static int test_0_vector3_max () {
 576                 var v1 = new Vector3 (1.0f, 2.0f, 3.0f);
 577                 var v2 = new Vector3 (5.0f, 6.0f, 7.0f);
 578
 579                 var v3 = vector3_max (v1, v2);
 580                 if (v3.X != 5.0f || v3.Y != 6.0f || v3.Z != 7.0f)
 581                         return 1;
 582                 v3 = vector3_max (v1, v1);
 583                 if (v3.X != 1.0f || v3.Y != 2.0f || v3.Z != 3.0f)
 584                         return 2;
 585                 return 0;
 586         }
 587
 588         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 589         public static Vector3 vector3_abs (Vector3 v1) {
 590                 return Vector3.Abs (v1);
 591         }
 592
 593         [Category ("!INTERPRETER")]
 594         public static int test_0_vector3_abs () {
 595                 var v1 = new Vector3 (-1.0f, -2.0f, -3.0f);
 596                 var v2 = new Vector3 (1.0f, 2.0f, 3.0f);
 597
 598                 var v3 = vector3_abs (v1);
 599                 if (v3.X != 1.0f || v3.Y != 2.0f || v3.Z != 3.0f)
 600                         return 1;
 601                 v3 = vector3_abs (v2);
 602                 if (v3.X != 1.0f || v3.Y != 2.0f || v3.Z != 3.0f)
 603                         return 2;
 604                 return 0;
 605         }
 606
 607         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 608         public static Vector3 vector3_sqrt (Vector3 v1) {
 609                 return Vector3.SquareRoot (v1);
 610         }
 611
 612         public static int test_0_vector3_sqrt () {
 613                 var v1 = new Vector3 (1.0f, 0.0f, 1.0f);
 614
 615                 var v3 = vector3_sqrt (v1);
 616                 if (v3.X != 1.0f || v3.Y != 0.0f || v3.Z != 1.0f)
 617                         return 1;
 618                 return 0;
 619         }
 620
 621         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 622         public static Vector3 vector3_add (Vector3 v1, Vector3 v2) {
 623                 return v1 + v2;
 624         }
 625
 626         public static int test_0_vector3_add () {
 627                 var v1 = new Vector3 (1.0f, 2.0f, 3.0f);
 628                 var v2 = new Vector3 (5.0f, 6.0f, 7.0f);
 629
 630                 var v3 = vector3_add (v1, v2);
 631                 if (v3.X != 6.0f || v3.Y != 8.0f || v3.Z != 10.0f)
 632                         return 1;
 633                 return 0;
 634         }
 635
 636         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 637         public static Vector3 vector3_sub (Vector3 v1, Vector3 v2) {
 638                 return v1 - v2;
 639         }
 640
 641         public static int test_0_vector3_sub () {
 642                 var v1 = new Vector3 (1.0f, 2.0f, 3.0f);
 643                 var v2 = new Vector3 (3.0f, 5.0f, 7.0f);
 644
 645                 var v3 = vector3_sub (v2, v1);
 646                 if (v3.X != 2.0f || v3.Y != 3.0f || v3.Z != 4.0f)
 647                         return 1;
 648                 return 0;
 649         }
 650
 651         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 652         public static Vector3 vector3_mul (Vector3 v1, Vector3 v2) {
 653                 return v1 * v2;
 654         }
 655
 656         public static int test_0_vector3_mul () {
 657                 var v1 = new Vector3 (1.0f, 2.0f, 3.0f);
 658                 var v2 = new Vector3 (3.0f, 5.0f, 6.0f);
 659
 660                 var v3 = vector3_mul (v2, v1);
 661                 if (v3.X != 3.0f || v3.Y != 10.0f || v3.Z != 18.0f)
 662                         return 1;
 663                 return 0;
 664         }
 665
 666         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 667         public static Vector3 vector3_mul_left (float v1, Vector3 v2) {
 668                 return v1 * v2;
 669         }
 670
 671         public static int test_0_vector3_mul_left () {
 672                 var v1 = new Vector3 (3.0f, 5.0f, 6.0f);
 673
 674                 var v3 = vector3_mul_left (2.0f, v1);
 675                 if (v3.X != 6.0f || v3.Y != 10.0f || v3.Z != 12.0f)
 676                         return 1;
 677                 return 0;
 678         }
 679
 680         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 681         public static Vector3 vector3_mul_right (Vector3 v1, float v2) {
 682                 return v1 * v2;
 683         }
 684
 685         public static int test_0_vector3_mul_right () {
 686                 var v1 = new Vector3 (3.0f, 5.0f, 6.0f);
 687
 688                 var v3 = vector3_mul_right (v1, 2.0f);
 689                 if (v3.X != 6.0f || v3.Y != 10.0f || v3.Z != 12.0f)
 690                         return 1;
 691                 return 0;
 692         }
 693
 694         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 695         public static Vector3 vector3_div (Vector3 v1, Vector3 v2) {
 696                 return v1 / v2;
 697         }
 698
 699         public static int test_0_vector3_div () {
 700                 var v1 = new Vector3 (9.0f, 10.0f, 12.0f);
 701                 var v2 = new Vector3 (3.0f, 5.0f, 6.0f);
 702
 703                 var v3 = vector3_div (v1, v2);
 704                 if (v3.X != 3.0f || v3.Y != 2.0f || v3.Z != 2.0f)
 705                         return 1;
 706                 return 0;
 707         }
 708
 709         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 710         public static Vector3 vector3_div_right (Vector3 v1, float v2) {
 711                 return v1 / v2;
 712         }
 713
 714         public static int test_0_vector3_div_right () {
 715                 var v1 = new Vector3 (9.0f, 15.0f, 21.0f);
 716
 717                 var v3 = vector3_div_right (v1, 3.0f);
 718                 if (v3.X != 3.0f || v3.Y != 5.0f || v3.Z != 7.0f)
 719                         return 1;
 720                 return 0;
 721         }
 722
 723         //
 724         // Vector<T>
 725         //
 726
 727         public static int test_0_vector_t_count () {
 728                 // This assumes a 16 byte simd register size
 729                 if (Vector<byte>.Count != 16)
 730                         return 1;
 731                 if (Vector<short>.Count != 8)
 732                         return 2;
 733                 if (Vector<int>.Count != 4)
 734                         return 3;
 735                 if (Vector<long>.Count != 2)
 736                         return 4;
 737                 return 0;
 738         }
 739
 740         public static int test_0_vector_t_zero () {
 741                 var v = Vector<byte>.Zero;
 742                 for (int i = 0; i < Vector<byte>.Count; ++i)
 743                         if (v [i] != 0)
 744                                 return 1;
 745                 var v2 = Vector<double>.Zero;
 746                 for (int i = 0; i < Vector<double>.Count; ++i)
 747                         if (v2 [i] != 0.0)
 748                                 return 2;
 749                 return 0;
 750         }
 751
 752         public static int test_0_vector_t_i1_accessor () {
 753                 var elems = new byte [] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
 754                 var v = new Vector<byte> (elems, 0);
 755                 for (int i = 0; i < Vector<byte>.Count; ++i)
 756                         if (v [i] != i + 1)
 757                                 return 1;
 758                 if (v [0] != 1)
 759                         return 2;
 760                 if (v [1] != 2)
 761                         return 2;
 762                 if (v [15] != 16)
 763                         return 2;
 764                 try {
 765                         int r = v [-1];
 766                         return 3;
 767                 } catch (IndexOutOfRangeException) {
 768                 }
 769                 try {
 770                         int r = v [16];
 771                         return 4;
 772                 } catch (IndexOutOfRangeException) {
 773                 }
 774                 return 0;
 775         }
 776
 777         public static int test_0_vector_t_i4_accessor () {
 778                 var elems = new int [] { 1, 2, 3, 4 };
 779                 var v = new Vector<int> (elems, 0);
 780                 for (int i = 0; i < Vector<int>.Count; ++i)
 781                         if (v [i] != i + 1)
 782                                 return 1;
 783                 if (v [0] != 1)
 784                         return 2;
 785                 if (v [1] != 2)
 786                         return 2;
 787                 if (v [3] != 4)
 788                         return 2;
 789                 try {
 790                         int r = v [-1];
 791                         return 3;
 792                 } catch (IndexOutOfRangeException) {
 793                 }
 794                 try {
 795                         int r = v [Vector<int>.Count];
 796                         return 4;
 797                 } catch (IndexOutOfRangeException) {
 798                 }
 799                 return 0;
 800         }
 801
 802         public static int test_0_vector_t_i8_accessor () {
 803                 var elems = new long [] { 1, 2 };
 804                 var v = new Vector<long> (elems, 0);
 805                 for (int i = 0; i < Vector<long>.Count; ++i)
 806                         if (v [i] != i + 1)
 807                                 return 1;
 808                 if (v [0] != 1)
 809                         return 2;
 810                 if (v [1] != 2)
 811                         return 2;
 812                 try {
 813                         var r = v [-1];
 814                         return 3;
 815                 } catch (IndexOutOfRangeException) {
 816                 }
 817                 try {
 818                         var r = v [Vector<long>.Count];
 819                         return 4;
 820                 } catch (IndexOutOfRangeException) {
 821                 }
 822                 return 0;
 823         }
 824
 825         public static int test_0_vector_t_r8_accessor () {
 826                 var elems = new double [] { 1.0, 2.0 };
 827                 var v = new Vector<double> (elems, 0);
 828                 for (int i = 0; i < Vector<double>.Count; ++i)
 829                         if (v [i] != (double)i + 1.0)
 830                                 return 1;
 831                 if (v [0] != 1.0)
 832                         return 2;
 833                 if (v [1] != 2.0)
 834                         return 2;
 835                 try {
 836                         var r = v [-1];
 837                         return 3;
 838                 } catch (IndexOutOfRangeException) {
 839                 }
 840                 try {
 841                         var r = v [Vector<double>.Count];
 842                         return 4;
 843                 } catch (IndexOutOfRangeException) {
 844                 }
 845                 return 0;
 846         }
 847
 848         public static int test_0_vector_t_i1_ctor_3 () {
 849                 var v = new Vector<byte> (5);
 850                 for (int i = 0; i < 16; ++i)
 851                         if (v [i] != 5)
 852                                 return 1;
 853                 return 0;
 854         }
 855
 856         public static int test_0_vector_t_i2_ctor_3 () {
 857                 var v = new Vector<short> (5);
 858                 for (int i = 0; i < 8; ++i)
 859                         if (v [i] != 5)
 860                                 return 1;
 861                 return 0;
 862         }
 863
 864         public static int test_0_vector_t_i4_ctor_3 () {
 865                 var v = new Vector<int> (0xffffeee);
 866                 for (int i = 0; i < 4; ++i)
 867                         if (v [i] != 0xffffeee)
 868                                 return 1;
 869                 return 0;
 870         }
 871
 872         public static int test_0_vector_t_i8_ctor_3 () {
 873                 var v = new Vector<long> (0xffffeeeeabcdefL);
 874                 for (int i = 0; i < 2; ++i)
 875                         if (v [i] != 0xffffeeeeabcdefL)
 876                                 return 1;
 877                 return 0;
 878         }
 879
 880         public static int test_0_vector_t_r4_ctor_3 () {
 881                 var v = new Vector<float> (0.5f);
 882                 for (int i = 0; i < 4; ++i) {
 883                         if (v [i] != 0.5f)
 884                                 return 1;
 885                 }
 886                 return 0;
 887         }
 888
 889         public static int test_0_vector_t_r8_ctor_3 () {
 890                 var v = new Vector<double> (0.5f);
 891                 for (int i = 0; i < 2; ++i) {
 892                         if (v [i] != 0.5f)
 893                                 return 1;
 894                 }
 895                 return 0;
 896         }
 897
 898         public static int test_0_vector_t_i1_ctor () {
 899                 var elems = new byte [] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
 900                                                                   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 };
 901                 var v = new Vector<byte> (elems, 16);
 902                 for (int i = 0; i < 16; ++i)
 903                         if (v [i] != i)
 904                                 return 1;
 905                 try {
 906                         var v2 = new Vector<byte> (elems, 16 + 4);
 907                         return 2;
 908                 } catch (IndexOutOfRangeException) {
 909                 }
 910                 return 0;
 911         }
 912
 913         public static int test_0_vector_t_i1_ctor_2 () {
 914                 var elems = new byte [] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
 915                 var v = new Vector<byte> (elems);
 916                 for (int i = 0; i < 16; ++i)
 917                         if (v [i] != i + 1)
 918                                 return 1;
 919                 try {
 920                         var elems2 = new byte [] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
 921                         var v2 = new Vector<byte> (elems2);
 922                         return 2;
 923                 } catch (IndexOutOfRangeException) {
 924                 }
 925                 return 0;
 926         }
 927
 928         public static int test_0_vector_t_r4_equal () {
 929                 var elems1 = new float [4] { 1.0f, 1.0f, 1.0f, 1.0f };
 930                 var v1 = new Vector<float> (elems1);
 931                 var elems2 = new float [4] { 1.0f, 2.0f, 1.0f, 2.0f };
 932                 var v2 = new Vector<float> (elems2);
 933                 Vector<int> v = Vector.Equals (v1, v2);
 934                 if (v [0] != -1 || v [1] != 0 || v [2] != -1 || v [3] != 0)
 935                         return 1;
 936                 return 0;
 937         }
 938
 939         public static int test_0_vector_t_r8_equal () {
 940                 var elems1 = new double [] { 1.0f, 1.0f };
 941                 var v1 = new Vector<double> (elems1);
 942                 var elems2 = new double [] { 1.0f, 2.0f };
 943                 var v2 = new Vector<double> (elems2);
 944                 Vector<long> v = Vector.Equals (v1, v2);
 945                 if (v [0] != -1 || v [1] != 0)
 946                         return 1;
 947                 return 0;
 948         }
 949
 950         public static int test_0_vector_t_i8_equal () {
 951                 var elems1 = new long [] { 1, 1 };
 952                 var v1 = new Vector<long> (elems1);
 953                 var elems2 = new long [] { 1, 2 };
 954                 var v2 = new Vector<long> (elems2);
 955                 Vector<long> v = Vector.Equals (v1, v2);
 956                 if (v [0] != -1 || v [1] != 0)
 957                         return 1;
 958                 return 0;
 959         }
 960
 961         public static int test_0_vector_t_i4_equal () {
 962                 var elems1 = new int [] { 1, 1, 1, 1 };
 963                 var v1 = new Vector<int> (elems1);
 964                 var elems2 = new int [] { 1, 2, 1, 2 };
 965                 var v2 = new Vector<int> (elems2);
 966                 Vector<int> v = Vector.Equals (v1, v2);
 967                 if (v [0] != -1 || v [1] != 0 || v [2] != -1 || v[3] != 0)
 968                         return 1;
 969                 return 0;
 970         }
 971
 972         /*
 973         public static int test_0_vector_t_u4_equal () {
 974                 var elems1 = new uint [] { 1, 1, 1, 1 };
 975                 var v1 = new Vector<uint> (elems1);
 976                 var elems2 = new uint [] { 1, 2, 1, 2 };
 977                 var v2 = new Vector<uint> (elems2);
 978                 Vector<uint> v = Vector.Equals (v1, v2);
 979                 if (v [0] != 0xffffffff || v [1] != 0 || v [2] != 0xffffffff || v[3] != 0)
 980                         return 1;
 981                 return 0;
 982         }
 983         */
 984
 985         public static int test_0_vector_t_i2_equal () {
 986                 var elems1 = new short [] { 1, 1, 1, 1, 1, 1, 1, 1 };
 987                 var v1 = new Vector<short> (elems1);
 988                 var elems2 = new short [] { 1, 2, 1, 2, 1, 2, 1, 2 };
 989                 var v2 = new Vector<short> (elems2);
 990                 Vector<short> v = Vector.Equals (v1, v2);
 991                 for (int i = 0; i < Vector<short>.Count; ++i) {
 992                         if (i % 2 == 0 && v [i] != -1)
 993                                 return 1;
 994                         if (i % 2 == 1 && v [i] != 0)
 995                                 return 1;
 996                 }
 997                 return 0;
 998         }
 999
1000         public static int test_0_vector_t_u2_equal () {
1001                 var elems1 = new ushort [] { 1, 1, 1, 1, 1, 1, 1, 1 };
1002                 var v1 = new Vector<ushort> (elems1);
1003                 var elems2 = new ushort [] { 1, 2, 1, 2, 1, 2, 1, 2 };
1004                 var v2 = new Vector<ushort> (elems2);
1005                 Vector<ushort> v = Vector.Equals (v1, v2);
1006                 for (int i = 0; i < Vector<ushort>.Count; ++i) {
1007                         if (i % 2 == 0 && v [i] != 0xffff)
1008                                 return 1;
1009                         if (i % 2 == 1 && v [i] != 0)
1010                                 return 1;
1011                 }
1012                 return 0;
1013         }
1014
1015         public static int test_0_vector_t_i1_equal () {
1016                 var elems1 = new sbyte [] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
1017                 var v1 = new Vector<sbyte> (elems1);
1018                 var elems2 = new sbyte [] { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 };
1019                 var v2 = new Vector<sbyte> (elems2);
1020                 Vector<sbyte> v = Vector.Equals (v1, v2);
1021                 for (int i = 0; i < Vector<sbyte>.Count; ++i) {
1022                         if (i % 2 == 0 && v [i] != -1)
1023                                 return 1;
1024                         if (i % 2 == 1 && v [i] != 0)
1025                                 return 1;
1026                 }
1027                 return 0;
1028         }
1029
1030         public static int test_0_vector_t_u1_equal () {
1031                 var elems1 = new byte [] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
1032                 var v1 = new Vector<byte> (elems1);
1033                 var elems2 = new byte [] { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 };
1034                 var v2 = new Vector<byte> (elems2);
1035                 Vector<byte> v = Vector.Equals (v1, v2);
1036                 for (int i = 0; i < Vector<byte>.Count; ++i) {
1037                         if (i % 2 == 0 && v [i] != 0xff)
1038                                 return 1;
1039                         if (i % 2 == 1 && v [i] != 0)
1040                                 return 1;
1041                 }
1042                 return 0;
1043         }
1044
1045         /* op_Explicit () -> Vector<int32> */
1046
1047         public static int test_0_vector_t_cast_vector_int32 () {
1048                 var v1 = new Vector<long> (new long [] { 0x123456789abcdef0L, 0x23456789abcdef01L });
1049                 var v = (Vector<int>)v1;
1050                 if (BitConverter.IsLittleEndian) {
1051                         if ((uint)v [0] != 0x9abcdef0 || (uint)v [1] != 0x12345678)
1052                                 return 1;
1053                         if ((uint)v [2] != 0xabcdef01 || (uint)v [3] != 0x23456789)
1054                                 return 2;
1055                 } else {
1056                         if ((uint)v [1] != 0x9abcdef0 || (uint)v [0] != 0x12345678)
1057                                 return 1;
1058                         if ((uint)v [3] != 0xabcdef01 || (uint)v [2] != 0x23456789)
1059                                 return 2;
1060                 }
1061                 return 0;
1062         }
1063
1064         /* Vector.GreaterThanOrEqual */
1065
1066         public static int test_0_vector_t_i1_ge () {
1067                 var elems1 = new sbyte [] { 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1 };
1068                 var v1 = new Vector<sbyte> (elems1);
1069                 var elems2 = new sbyte [] { 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2 };
1070                 var v2 = new Vector<sbyte> (elems2);
1071                 Vector<sbyte> v = Vector.GreaterThanOrEqual (v1, v2);
1072                 for (int i = 0; i < Vector<sbyte>.Count; ++i) {
1073                         if (i % 2 == 0 && v [i] != -1)
1074                                 return 1;
1075                         if (i % 2 == 1 && v [i] != 0)
1076                                 return 1;
1077                 }
1078                 return 0;
1079         }
1080
1081         public static int test_0_vector_t_i2_ge () {
1082                 var elems1 = new short [] { 1, 1, 0, 1, 1, 1, 0, 1 };
1083                 var v1 = new Vector<short> (elems1);
1084                 var elems2 = new short [] { 0, 2, 0, 2, 0, 2, 0, 2 };
1085                 var v2 = new Vector<short> (elems2);
1086                 Vector<short> v = Vector.GreaterThanOrEqual (v1, v2);
1087                 for (int i = 0; i < Vector<short>.Count; ++i) {
1088                         if (i % 2 == 0 && v [i] != -1)
1089                                 return 1;
1090                         if (i % 2 == 1 && v [i] != 0)
1091                                 return 1;
1092                 }
1093                 return 0;
1094         }
1095
1096         public static int test_0_vector_t_i4_ge () {
1097                 var elems1 = new int [] { 1, 1, 0, 1 };
1098                 var v1 = new Vector<int> (elems1);
1099                 var elems2 = new int [] { 0, 2, 0, 2 };
1100                 var v2 = new Vector<int> (elems2);
1101                 Vector<int> v = Vector.GreaterThanOrEqual (v1, v2);
1102                 if (v [0] != -1 || v [1] != 0 || v [2] != -1 || v[3] != 0)
1103                         return 1;
1104                 return 0;
1105         }
1106
1107         public static int test_0_vector_t_i8_ge () {
1108                 var elems1 = new long [] { 1, 1 };
1109                 var v1 = new Vector<long> (elems1);
1110                 var elems2 = new long [] { 0, 1 };
1111                 var v2 = new Vector<long> (elems2);
1112                 Vector<long> v = Vector.GreaterThanOrEqual (v1, v2);
1113                 if (v [0] != -1 || v [1] != -1)
1114                         return 1;
1115                 return 0;
1116         }
1117
1118         /* Vector.LessThan */
1119
1120         public static int test_0_vector_t_i1_lt () {
1121                 var elems1 = new sbyte [] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
1122                 var v1 = new Vector<sbyte> (elems1);
1123                 var elems2 = new sbyte [] { 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2 };
1124                 var v2 = new Vector<sbyte> (elems2);
1125                 Vector<sbyte> v = Vector.LessThan (v2, v1);
1126                 for (int i = 0; i < Vector<sbyte>.Count; ++i) {
1127                         if (i % 2 == 0 && v [i] != -1)
1128                                 return 1;
1129                         if (i % 2 == 1 && v [i] != 0)
1130                                 return 1;
1131                 }
1132                 return 0;
1133         }
1134
1135         /* Vector.GreaterThan */
1136
1137         public static int test_0_vector_t_i1_gt () {
1138                 var elems1 = new sbyte [] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
1139                 var v1 = new Vector<sbyte> (elems1);
1140                 var elems2 = new sbyte [] { 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2 };
1141                 var v2 = new Vector<sbyte> (elems2);
1142                 Vector<sbyte> v = Vector.GreaterThan (v1, v2);
1143                 for (int i = 0; i < Vector<sbyte>.Count; ++i) {
1144                         if (i % 2 == 0 && v [i] != -1)
1145                                 return 1;
1146                         if (i % 2 == 1 && v [i] != 0)
1147                                 return 1;
1148                 }
1149                 return 0;
1150         }
1151
1152         /* Vector.LessThanOrEqual */
1153         public static int test_0_vector_t_i1_le () {
1154                 var elems1 = new sbyte [] { 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2 };
1155                 var v1 = new Vector<sbyte> (elems1);
1156                 var elems2 = new sbyte [] { 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1 };
1157                 var v2 = new Vector<sbyte> (elems2);
1158                 Vector<sbyte> v = Vector.LessThanOrEqual (v1, v2);
1159                 for (int i = 0; i < Vector<sbyte>.Count; ++i) {
1160                         if (i % 2 == 0 && v [i] != -1)
1161                                 return 1;
1162                         if (i % 2 == 1 && v [i] != 0)
1163                                 return 1;
1164                 }
1165                 return 0;
1166         }
1167
1168         /* Vector.Abs */
1169
1170         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1171         public static Vector<T> vector_t_abs<T> (Vector<T> v1) where T: struct {
1172                 return Vector.Abs (v1);
1173         }
1174
1175         public static int test_0_vector_t_u1_abs () {
1176                 var elems1 = new byte [] { 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2 };
1177                 var v1 = new Vector<byte> (elems1);
1178
1179                 if (vector_t_abs (v1) != v1)
1180                         return 1;
1181                 return 0;
1182         }
1183
1184         public static int test_0_vector_t_u2_abs () {
1185                 var elems1 = new ushort [] { 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2 };
1186                 var v1 = new Vector<ushort> (elems1);
1187
1188                 if (vector_t_abs (v1) != v1)
1189                         return 1;
1190                 return 0;
1191         }
1192
1193         public static int test_0_vector_t_u4_abs () {
1194                 var elems1 = new uint [] { 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2 };
1195                 var v1 = new Vector<uint> (elems1);
1196
1197                 if (vector_t_abs (v1) != v1)
1198                         return 1;
1199                 return 0;
1200         }
1201
1202         public static int test_0_vector_t_u8_abs () {
1203                 var elems1 = new ulong [] { 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2 };
1204                 var v1 = new Vector<ulong> (elems1);
1205
1206                 if (vector_t_abs (v1) != v1)
1207                         return 1;
1208                 return 0;
1209         }
1210
1211         public static int test_0_vector_t_i1_abs () {
1212                 var elems1 = new sbyte [] { 1, -2, 1, -2, 1, -2, 1, -2, 1, -2, 1, -2, 1, -2, 1, -2 };
1213                 var v1 = new Vector<sbyte> (elems1);
1214                 var elems2 = new sbyte [] { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 };
1215                 var v2 = new Vector<sbyte> (elems2);
1216
1217                 if (vector_t_abs (v1) != v2)
1218                         return 1;
1219                 return 0;
1220         }
1221
1222         // Vector<T>.Add
1223         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1224         public static Vector<T> vector_add<T> (Vector<T> v1, Vector<T> v2) where T: struct {
1225                 return v1 + v2;
1226         }
1227
1228         public static int test_0_vector_byte_add () {
1229                 var v1 = new Vector<byte> (new byte[] { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 });
1230                 var v2 = new Vector<byte> (new byte[] { 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4 });
1231
1232                 var res = vector_add (v1, v1);
1233                 if (res != v2)
1234                         return 1;
1235                 return 0;
1236         }
1237
1238         public static int test_0_vector_sbyte_add () {
1239                 var v1 = new Vector<sbyte> (new sbyte[] { 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1 });
1240                 var v2 = new Vector<sbyte> (new sbyte[] { 2, -2, 2, -2, 2, -2, 2, -2, 2, -2, 2, -2, 2, -2, 2, -2 });
1241
1242                 var res = vector_add (v1, v1);
1243                 if (res != v2)
1244                         return 1;
1245                 return 0;
1246         }
1247
1248         public static int test_0_vector_ushort_add () {
1249                 var v1 = new Vector<ushort> (new ushort[] { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 });
1250                 var v2 = new Vector<ushort> (new ushort[] { 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4 });
1251
1252                 var res = vector_add (v1, v1);
1253                 if (res != v2)
1254                         return 1;
1255                 return 0;
1256         }
1257
1258         public static int test_0_vector_short_add () {
1259                 var v1 = new Vector<short> (new short[] { 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1 });
1260                 var v2 = new Vector<short> (new short[] { 2, -2, 2, -2, 2, -2, 2, -2, 2, -2, 2, -2, 2, -2, 2, -2 });
1261
1262                 var res = vector_add (v1, v1);
1263                 if (res != v2)
1264                         return 1;
1265                 return 0;
1266         }
1267
1268         public static int test_0_vector_uint_add () {
1269                 var v1 = new Vector<uint> (new uint[] { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 });
1270                 var v2 = new Vector<uint> (new uint[] { 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4 });
1271
1272                 var res = vector_add (v1, v1);
1273                 if (res != v2)
1274                         return 1;
1275                 return 0;
1276         }
1277
1278         public static int test_0_vector_int_add () {
1279                 var v1 = new Vector<int> (new int[] { 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1 });
1280                 var v2 = new Vector<int> (new int[] { 2, -2, 2, -2, 2, -2, 2, -2, 2, -2, 2, 2, 2, -2, 2, -2 });
1281
1282                 var res = vector_add (v1, v1);
1283                 if (res != v2)
1284                         return 1;
1285                 return 0;
1286         }
1287
1288         public static int test_0_vector_double_add () {
1289                 var v1 = new Vector<double> (new double[] { 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0 });
1290                 var v2 = new Vector<double> (new double[] { 2.0, -2.0, 2.0, -2.0, 2.0, -2.0, 2.0, -2.0, 2.0, -2.0, 2.0, 2.0, 2.0, -2.0, 2.0, -2.0 });
1291
1292                 var res = vector_add (v1, v1);
1293                 if (res != v2)
1294                         return 1;
1295                 return 0;
1296         }
1297
1298         public static int test_0_vector_float_add () {
1299                 var v1 = new Vector<float> (new float[] { 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f });
1300                 var v2 = new Vector<float> (new float[] { 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, 2.0f, 2.0f, -2.0f, 2.0f, -2.0f });
1301
1302                 var res = vector_add (v1, v1);
1303                 if (res != v2)
1304                         return 1;
1305                 return 0;
1306         }
1307
1308         // Vector<T>.op_Subtraction
1309
1310         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1311         public static Vector<T> vector_sub<T> (Vector<T> v1, Vector<T> v2) where T: struct {
1312                 return v1 - v2;
1313         }
1314
1315         public static int test_0_vector_byte_sub () {
1316                 var v1 = new Vector<byte> (new byte[] { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 });
1317
1318                 var res = vector_sub (v1, v1);
1319                 if (res != Vector<byte>.Zero)
1320                         return 1;
1321                 return 0;
1322         }
1323
1324         public static int test_0_vector_double_sub () {
1325                 var v1 = new Vector<double> (new double[] { 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0 });
1326
1327                 var res = vector_sub (v1, v1);
1328                 if (res != Vector<double>.Zero)
1329                         return 1;
1330                 return 0;
1331         }
1332
1333         public static int test_0_vector_float_sub () {
1334                 var v1 = new Vector<float> (new float[] { 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f });
1335
1336                 var res = vector_sub (v1, v1);
1337                 if (res != Vector<float>.Zero)
1338                         return 1;
1339                 return 0;
1340         }
1341
1342         // Vector<T>.op_Multiply
1343         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1344         public static Vector<T> vector_mul<T> (Vector<T> v1, Vector<T> v2) where T: struct {
1345                 return v1 * v2;
1346         }
1347
1348         public static int test_0_vector_int_mul () {
1349                 var v1 = new Vector<int> (new int[] { 1, 2, -1, 2, 1, 2, -1, 2, 1, -2, 1, 2, 1, 2, -1, 2 });
1350                 var v2 = new Vector<int> (new int[] { 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4 });
1351
1352                 var res = vector_mul (v1, v1);
1353                 if (res != v2)
1354                         return 1;
1355                 return 0;
1356         }
1357
1358         public static int test_0_vector_double_mul () {
1359                 var v1 = new Vector<double> (new double[] { 2.0, -1.0, 2.0, -1.0 });
1360                 var v2 = new Vector<double> (new double[] { 4.0, 1.0, 4.0, 1.0 });
1361
1362                 var res = vector_mul (v1, v1);
1363                 if (res != v2)
1364                         return 1;
1365                 return 0;
1366         }
1367
1368         public static int test_0_vector_float_mul () {
1369                 var v1 = new Vector<float> (new float[] { 2.0f, -1.0f, 2.0f, -1.0f });
1370                 var v2 = new Vector<float> (new float[] { 4.0f, 1.0f, 4.0f, 1.0f });
1371
1372                 var res = vector_mul (v1, v1);
1373                 if (res != v2)
1374                         return 1;
1375                 return 0;
1376         }
1377
1378         // Vector<T>.op_Division
1379         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1380         public static Vector<T> vector_div<T> (Vector<T> v1, Vector<T> v2) where T: struct {
1381                 return v1 / v2;
1382         }
1383
1384         public static int test_0_vector_double_div () {
1385                 var v1 = new Vector<double> (new double[] { 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0 });
1386                 var v2 = new Vector<double> (new double[] { 1.0, 1.0, 1.0, 1.0 });
1387
1388                 var res = vector_div (v1, v1);
1389                 if (res != v2)
1390                         return 1;
1391                 return 0;
1392         }
1393
1394         public static int test_0_vector_float_div () {
1395                 var v1 = new Vector<float> (new float[] { 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f });
1396                 var v2 = new Vector<float> (new float[] { 1.0f, 1.0f, 1.0f, 1.0f });
1397
1398                 var res = vector_div (v1, v1);
1399                 if (res != v2)
1400                         return 1;
1401                 return 0;
1402         }
1403
1404         // Vector<T>.CopyTo
1405         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1406         public static void vector_copyto<T> (Vector<T> v1, T[] array, int index) where T: struct {
1407                 v1.CopyTo (array, index);
1408         }
1409
1410         public static int test_0_vector_byte_copyto () {
1411                 var v1 = new Vector<byte> (new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 });
1412
1413                 byte[] arr = new byte [256];
1414                 vector_copyto (v1, arr, 1);
1415                 for (int i = 0; i < 16; ++i)
1416                         if (arr [i + 1] != (i + 1))
1417                                 return 1;
1418                 vector_copyto (v1, arr, 240);
1419                 try {
1420                         vector_copyto (v1, arr, 241);
1421                         return 1;
1422                 } catch (ArgumentException) {
1423                 }
1424                 return 0;
1425         }
1426 }