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