src/test-number.vala

   1 /*
   2  * Copyright (C) 2008-2012 Robert Ancell.
   3  *
   4  * This program is free software: you can redistribute it and/or modify it under
   5  * the terms of the GNU General Public License as published by the Free Software
   6  * Foundation, either version 2 of the License, or (at your option) any later
   7  * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
   8  * license.
   9  */
  10
  11 private int fail_count = 0;
  12 private int pass_count = 0;
  13
  14 private void pass (string? text = null)
  15 {
  16     //stdout.printf ("PASS: %s\n", text);
  17     pass_count++;
  18 }
  19
  20 private void fail (string text)
  21 {
  22     stdout.printf ("*FAIL: %s\n", text);
  23     fail_count++;
  24 }
  25
  26 private void test_integer ()
  27 {
  28     for (var a = -10; a <= 10; a++)
  29     {
  30         var z = new Number.integer (a);
  31         if (z.to_integer () != a)
  32         {
  33             fail ("Number.integer (%d).to_integer () -> %lli, expected %i".printf (a, z.to_integer (), a));
  34             return;
  35         }
  36     }
  37
  38     pass ();
  39 }
  40
  41 private void test_unsigned_integer ()
  42 {
  43     for (var a = 0; a <= 10; a++)
  44     {
  45         var z = new Number.unsigned_integer (a);
  46         if (z.to_unsigned_integer () != a)
  47         {
  48             fail ("Number.unsigned_integer (%d).to_unsigned_integer () -> %i, expected %i".printf (a, (int) z.to_unsigned_integer (), a));
  49             return;
  50         }
  51     }
  52
  53     pass ();
  54 }
  55
  56 private void test_fraction ()
  57 {
  58     for (var a = 0; a <= 10; a++)
  59     {
  60         for (var b = 1; b <= 10; b++)
  61         {
  62             var z = new Number.fraction (a, b);
  63             var expected = (double) a / b;
  64             if (!double_matches (z, expected))
  65             {
  66                 fail ("Number.fraction (%d, %d) -> %f, expected %f".printf (a, b, z.to_double (), expected));
  67                 return;
  68             }
  69         }
  70     }
  71
  72     pass ();
  73 }
  74
  75 private void test_float ()
  76 {
  77     for (var a = -10.0f; a <= 10.0f; a += 0.5f)
  78     {
  79         var z = new Number.float (a);
  80         if (z.to_float () != a)
  81         {
  82             fail ("Number.float (%f).to_float () -> %f, expected %f".printf (a, z.to_float (), a));
  83             return;
  84         }
  85     }
  86
  87     pass ();
  88 }
  89
  90 private void test_double ()
  91 {
  92     for (var a = -10.0; a <= 10.0; a += 0.5)
  93     {
  94         var z = new Number.double (a);
  95         if (z.to_double () != a)
  96         {
  97             fail ("Number.double (%f).to_double () -> %f, expected %f".printf (a, z.to_double (), a));
  98             return;
  99         }
 100     }
 101
 102     pass ();
 103 }
 104
 105 private void test_complex ()
 106 {
 107     for (var a = -10; a <= 10; a++)
 108     {
 109         for (var b = -10; b <= 10; b++)
 110         {
 111             var z = new Number.complex (new Number.integer (a), new Number.integer (b));
 112             var re_expected = a;
 113             var im_expected = b;
 114             if (z.real_component ().to_integer () != re_expected || z.imaginary_component ().to_integer () != im_expected)
 115             {
 116                 fail ("Number.complex (%d%+di) -> %d%+di, expected %d%+di".printf (a, b, (int) z.real_component ().to_integer (), (int) z.imaginary_component ().to_integer (), re_expected, im_expected));
 117                 return;
 118             }
 119         }
 120     }
 121 }
 122
 123 private void test_polar ()
 124 {
 125     for (var ri = -10; ri <= 10; ri++)
 126     {
 127         for (var theta_i = -10; theta_i <= 10; theta_i++)
 128         {
 129             var r = (double) ri;
 130             var theta = 2 * Math.PI * theta_i / 10.0;
 131             var z = new Number.polar (new Number.double (r), new Number.double (theta));
 132             var re_expected = r * Math.cos (theta);
 133             var im_expected = r * Math.sin (theta);
 134             if (!double_matches (z.real_component (), re_expected) || !double_matches (z.imaginary_component (), im_expected))
 135             {
 136                 fail ("Number.polar (%f, %f) -> %f%+fi, expected %f%+fi".printf (r, theta, z.real_component ().to_double (), z.imaginary_component ().to_double (), re_expected, im_expected));
 137                 return;
 138             }
 139         }
 140     }
 141 }
 142
 143 private void test_i ()
 144 {
 145     var z = new Number.i ();
 146     if (z.real_component ().to_integer () != 0 && z.imaginary_component ().to_integer () != 1)
 147     {
 148         fail ("Number.i () -> %d%+di, expected i".printf ((int) z.real_component ().to_integer (), (int) z.imaginary_component ().to_integer ()));
 149         return;
 150     }
 151
 152     pass ();
 153 }
 154
 155 private void test_pi ()
 156 {
 157     var z = new Number.pi ();
 158     var expected = Math.PI;
 159     if (!double_matches (z, expected))
 160     {
 161         fail ("Number.pi () -> %f, expected %f".printf (z.to_double (), expected));
 162         return;
 163     }
 164
 165     pass ();
 166 }
 167
 168 private void test_eulers ()
 169 {
 170     var z = new Number.eulers ();
 171     var expected = Math.E;
 172     if (!double_matches (z, expected))
 173     {
 174         fail ("Number.eulers () -> %f, expected %f".printf (z.to_double (), expected));
 175         return;
 176     }
 177
 178     pass ();
 179 }
 180
 181 private void test_string ()
 182 {
 183     for (var a = -10; a <= 10; a++)
 184     {
 185         var s = "%d".printf (a);
 186         var z = mp_set_from_string (s);
 187         if (z == null)
 188         {
 189             fail ("mp_set_from_string (\"%s\") -> null".printf (s));
 190             return;
 191         }
 192
 193         if (z.to_integer () != a)
 194         {
 195             fail ("mp_set_from_string (\"%s\").to_integer () -> %d, expected %d".printf (s, (int) z.to_integer (), a));
 196             return;
 197         }
 198     }
 199
 200     pass ();
 201 }
 202
 203 private void test_sgn ()
 204 {
 205     for (var a = -10; a <= 10; a++)
 206     {
 207         var z = new Number.integer (a);
 208         var expected = 0;
 209         if (a < 0)
 210             expected = -1;
 211         if (a > 0)
 212             expected = 1;
 213         if (z.sgn ().to_integer () != expected)
 214         {
 215             fail ("(%d).sgn () -> %d, expected %d".printf (a, (int) z.sgn ().to_integer (), expected));
 216             return;
 217         }
 218     }
 219
 220     pass ();
 221 }
 222
 223 private void test_invert_sign ()
 224 {
 225     for (var a = -10; a <= 10; a++)
 226     {
 227         var z = new Number.integer (a);
 228         var expected = -a;
 229         if (z.invert_sign ().to_integer () != expected)
 230         {
 231             fail ("(%d).invert_sign () -> %d, expected %d".printf (a, (int) z.invert_sign ().to_integer (), expected));
 232             return;
 233         }
 234     }
 235
 236     pass ();
 237 }
 238
 239 private void test_abs ()
 240 {
 241     for (var a = -10; a <= 10; a++)
 242     {
 243         var z = new Number.integer (a);
 244         var expected = a.abs ();
 245         if (z.abs ().to_integer () != expected)
 246         {
 247             fail ("(%d).abs () -> %d, expected %d".printf (a, (int) z.abs ().to_integer (), expected));
 248             return;
 249         }
 250     }
 251
 252     pass ();
 253 }
 254
 255 private void test_arg ()
 256 {
 257     for (var a = -10; a <= 10; a++)
 258     {
 259         for (var b = -10; b <= 10; b++)
 260         {
 261             var z = new Number.complex (new Number.integer (a), new Number.integer (b));
 262             z = z.arg ();
 263             var expected = Math.atan2 (b, a);
 264             if (!double_matches (z.real_component (), expected) || !z.imaginary_component ().is_zero ())
 265             {
 266                 fail ("(%d%+di).arg () -> %f%+fi, expected %f".printf (a, b, z.real_component ().to_double (), z.imaginary_component ().to_double (), expected));
 267                 return;
 268             }
 269         }
 270     }
 271 }
 272
 273 private void test_conjugate ()
 274 {
 275     for (var a = -10; a <= 10; a++)
 276     {
 277         for (var b = -10; b <= 10; b++)
 278         {
 279             var z = new Number.complex (new Number.integer (a), new Number.integer (b));
 280             z = z.conjugate ();
 281             var re_expected = a;
 282             var im_expected = -b;
 283             if (z.real_component ().to_integer () != re_expected || z.imaginary_component ().to_integer () != im_expected)
 284             {
 285                 fail ("(%d%+di).real_component () -> %d%+di, expected %d%+di".printf (a, b, (int) z.real_component ().to_integer (), (int) z.imaginary_component ().to_integer (), re_expected, im_expected));
 286                 return;
 287             }
 288         }
 289     }
 290 }
 291
 292 private void test_real_component ()
 293 {
 294     for (var a = -10; a <= 10; a++)
 295     {
 296         for (var b = -10; b <= 10; b++)
 297         {
 298             var z = new Number.complex (new Number.integer (a), new Number.integer (b));
 299             var expected = a;
 300             if (z.real_component ().to_integer () != expected)
 301             {
 302                 fail ("(%d+%di).real_component () -> %d, expected %d".printf (a, b, (int) z.real_component ().to_integer (), expected));
 303                 return;
 304             }
 305         }
 306     }
 307
 308     pass ();
 309 }
 310
 311 private void test_imaginary_component ()
 312 {
 313     for (var a = -10; a <= 10; a++)
 314     {
 315         for (var b = -10; b <= 10; b++)
 316         {
 317             var z = new Number.complex (new Number.integer (a), new Number.integer (b));
 318             var expected = b;
 319             if (z.imaginary_component ().to_integer () != expected)
 320             {
 321                 fail ("(%d+%di).imaginary_component () -> %d, expected %d".printf (a, b, (int) z.imaginary_component ().to_integer (), expected));
 322                 return;
 323             }
 324         }
 325     }
 326
 327     pass ();
 328 }
 329
 330 private bool double_matches (Number a, double b)
 331 {
 332     return double_string (a.to_double ()) == double_string (b);
 333 }
 334
 335 private string double_string (double x)
 336 {
 337     var value = "%.6f".printf (x);
 338     if (value == "-0.000000")
 339         return "0.000000";
 340     else
 341         return value;
 342 }
 343
 344 private void test_integer_component ()
 345 {
 346     for (var ai = -100; ai <= 100; ai++)
 347     {
 348         var a = ai / 10.0;
 349         var z = new Number.double (a).integer_component ();
 350         var expected = Math.trunc (a);
 351         if (!double_matches (z, expected))
 352         {
 353             fail ("(%f).integer_component () -> %f, expected %f".printf (a, z.to_double (), expected));
 354             return;
 355         }
 356     }
 357
 358     pass ();
 359 }
 360
 361 private void test_fractional_component ()
 362 {
 363     for (var ai = -100; ai <= 100; ai++)
 364     {
 365         var a = ai / 10.0;
 366         var z = new Number.double (a).fractional_component ();
 367         var expected = a - Math.trunc (a);
 368         if (!double_matches (z, expected))
 369         {
 370             fail ("(%f).fractional_component () -> %f, expected %f".printf (a, z.to_double (), expected));
 371             return;
 372         }
 373     }
 374
 375     pass ();
 376 }
 377
 378 private void test_fractional_part ()
 379 {
 380     for (var ai = -100; ai <= 100; ai++)
 381     {
 382         var a = ai / 10.0;
 383         var z = new Number.double (a).fractional_part ();
 384         var expected = a - Math.floor (a);
 385         if (!double_matches (z, expected))
 386         {
 387             fail ("(%f).fractional_part () -> %f, expected %f".printf (a, z.to_double (), expected));
 388             return;
 389         }
 390     }
 391
 392     pass ();
 393 }
 394
 395 private void test_floor ()
 396 {
 397     for (var ai = -100; ai <= 100; ai++)
 398     {
 399         var a = ai / 10.0;
 400         var z = new Number.double (a).floor ();
 401         var expected = Math.floor (a);
 402         if (!double_matches (z, expected))
 403         {
 404             fail ("(%f).floor () -> %f, expected %f".printf (a, z.to_double (), expected));
 405             return;
 406         }
 407     }
 408
 409     pass ();
 410 }
 411
 412 private void test_ceiling ()
 413 {
 414     for (var ai = -100; ai <= 100; ai++)
 415     {
 416         var a = ai / 10.0;
 417         var z = new Number.double (a).ceiling ();
 418         var expected = Math.ceil (a);
 419         if (!double_matches (z, expected))
 420         {
 421             fail ("(%f).ceiling () -> %f, expected %f".printf (a, z.to_double (), expected));
 422             return;
 423         }
 424     }
 425
 426     pass ();
 427 }
 428
 429 private void test_round ()
 430 {
 431     for (var ai = -100; ai <= 100; ai++)
 432     {
 433         var a = ai / 10.0;
 434         var z = new Number.double (a).round ();
 435         var expected = Math.round (a);
 436         if (!double_matches (z, expected))
 437         {
 438             fail ("(%f).round () -> %f, expected %f".printf (a, z.to_double (), expected));
 439             return;
 440         }
 441     }
 442
 443     pass ();
 444 }
 445
 446 private void test_reciprocal ()
 447 {
 448     for (var a = -10; a <= 10; a++)
 449     {
 450         if (a == 0)
 451             continue;
 452
 453         var z = new Number.double (a).reciprocal ();
 454         var expected = 1.0 / a;
 455         if (!double_matches (z, expected))
 456         {
 457             fail ("(%f).reciprocal () -> %f, expected %f".printf (a, z.to_double (), expected));
 458             return;
 459         }
 460
 461         z = new Number.double (expected).reciprocal ();
 462         if (!double_matches (z, a))
 463         {
 464             fail ("(%f).reciprocal () -> %f, expected %f".printf (expected, z.to_double (), a));
 465             return;
 466         }
 467     }
 468
 469     pass ();
 470 }
 471
 472 private void test_epowy ()
 473 {
 474     for (var ai = -100; ai <= 100; ai++)
 475     {
 476         var a = ai / 10.0;
 477         var z = new Number.double (a).epowy ();
 478         var expected = Math.exp (a);
 479         if (!double_matches (z, expected))
 480         {
 481             fail ("(%f).epowy () -> %f, expected %f".printf (a, z.to_double (), expected));
 482             return;
 483         }
 484     }
 485
 486     pass ();
 487 }
 488
 489 private void test_xpowy ()
 490 {
 491     for (var a = -10; a <= 10; a++)
 492     {
 493         for (var b = -10; b <= 10; b++)
 494         {
 495             var z = new Number.integer (a).xpowy (new Number.integer (b));
 496             var expected = 1.0;
 497             if (a == 0)
 498             {
 499                 if (b != 0)
 500                     expected = 0.0;
 501             }
 502             else
 503             {
 504                 if (b < 0)
 505                     for (var i = 0; i > b; i--)
 506                         expected /= a;
 507                 else if (b > 0)
 508                     for (var i = 0; i < b; i++)
 509                         expected *= a;
 510             }
 511
 512             if (!double_matches (z, expected))
 513             {
 514                 fail ("(%d).xpowy (%d) -> %f, expected %f".printf (a, b, z.to_double (), expected));
 515                 return;
 516             }
 517         }
 518     }
 519
 520     pass ();
 521 }
 522
 523 private void test_xpowy_integer ()
 524 {
 525     for (var a = -10; a <= 10; a++)
 526     {
 527         for (var b = -10; b <= 10; b++)
 528         {
 529             var z = new Number.integer (a).xpowy_integer (b);
 530             var expected = 1.0;
 531             if (a == 0)
 532             {
 533                 if (b != 0)
 534                     expected = 0.0;
 535             }
 536             else
 537             {
 538                 if (b < 0)
 539                     for (var i = 0; i > b; i--)
 540                         expected /= a;
 541                 else if (b > 0)
 542                     for (var i = 0; i < b; i++)
 543                         expected *= a;
 544             }
 545
 546             if (!double_matches (z, expected))
 547             {
 548                 fail ("(%d).xpowy_integer (%d) -> %f, expected %f".printf (a, b, z.to_double (), expected));
 549                 return;
 550             }
 551         }
 552     }
 553
 554     pass ();
 555 }
 556
 557 private void test_root3 ()
 558 {
 559     for (var a = -10; a <= 10; a++)
 560     {
 561         var z = new Number.double (a).root (3);
 562         var expected = Math.cbrt (a);
 563         if (!double_matches (z, expected))
 564         {
 565             fail ("(%f).root (3) -> %f, expected %f".printf (a, z.to_double (), expected));
 566             return;
 567         }
 568     }
 569
 570     pass ();
 571 }
 572
 573 private void test_sqrt ()
 574 {
 575     for (var a = 0; a <= 10; a++)
 576     {
 577         var z = new Number.double (a).sqrt ();
 578         var expected = Math.sqrt (a);
 579         if (!double_matches (z, expected))
 580         {
 581             fail ("(%f).sqrt () -> %f, expected %f".printf (a, z.to_double (), expected));
 582             return;
 583         }
 584     }
 585
 586     pass ();
 587 }
 588
 589 private void test_ln ()
 590 {
 591     for (var a = 1; a <= 10; a++)
 592     {
 593         var z = new Number.double (a).ln ();
 594         var expected = Math.log (a);
 595         if (!double_matches (z, expected))
 596         {
 597             fail ("(%f).ln () -> %f, expected %f".printf (a, z.to_double (), expected));
 598             return;
 599         }
 600     }
 601
 602     pass ();
 603 }
 604
 605 private void test_logarithm2 ()
 606 {
 607     for (var a = 1; a <= 10; a++)
 608     {
 609         var z = new Number.double (a).logarithm (2);
 610         var expected = Math.log2 (a);
 611         if (!double_matches (z, expected))
 612         {
 613             fail ("(%f).logarithm (2) -> %f, expected %f".printf (a, z.to_double (), expected));
 614             return;
 615         }
 616     }
 617
 618     pass ();
 619 }
 620
 621 private void test_logarithm10 ()
 622 {
 623     for (var a = 1; a <= 10; a++)
 624     {
 625         var z = new Number.double (a).logarithm (10);
 626         var expected = Math.log10 (a);
 627         if (!double_matches (z, expected))
 628         {
 629             fail ("(%f).logarithm (10) -> %f, expected %f".printf (a, z.to_double (), expected));
 630             return;
 631         }
 632     }
 633
 634     pass ();
 635 }
 636
 637 private void test_is_zero ()
 638 {
 639     for (var a = -10; a <= 10; a++)
 640     {
 641         var z = new Number.integer (a);
 642         var expected = a == 0;
 643         if (z.is_zero () != expected)
 644         {
 645             fail ("(%d).is_zero () -> %s, expected %s".printf (a, z.is_zero () ? "true" : "false", expected ? "true" : "false"));
 646             return;
 647         }
 648     }
 649
 650     pass ();
 651 }
 652
 653 private void test_is_negative ()
 654 {
 655     for (var a = -10; a <= 10; a++)
 656     {
 657         var z = new Number.integer (a);
 658         var expected = a < 0;
 659         if (z.is_negative () != expected)
 660         {
 661             fail ("(%d).is_negative () -> %s, expected %s".printf (a, z.is_negative () ? "true" : "false", expected ? "true" : "false"));
 662             return;
 663         }
 664     }
 665
 666     pass ();
 667 }
 668
 669 private void test_is_integer ()
 670 {
 671     for (var a = -10; a <= 10; a++)
 672     {
 673         var z = new Number.integer (a);
 674         var expected = true;
 675         if (z.is_integer () != expected)
 676         {
 677             fail ("(%d).is_integer () -> %s, expected %s".printf (a, z.is_integer () ? "true" : "false", expected ? "true" : "false"));
 678             return;
 679         }
 680     }
 681
 682     pass ();
 683 }
 684
 685 private void test_is_positive_integer ()
 686 {
 687     for (var a = -10; a <= 10; a++)
 688     {
 689         var z = new Number.integer (a);
 690         var expected = a >= 0;
 691         if (z.is_positive_integer () != expected)
 692         {
 693             fail ("(%d).is_positive_integer () -> %s, expected %s".printf (a, z.is_positive_integer () ? "true" : "false", expected ? "true" : "false"));
 694             return;
 695         }
 696     }
 697
 698     pass ();
 699 }
 700
 701 private void test_is_natural ()
 702 {
 703     for (var a = -10; a <= 10; a++)
 704     {
 705         var z = new Number.integer (a);
 706         var expected = a > 0;
 707         if (z.is_natural () != expected)
 708         {
 709             fail ("(%d).is_natural () -> %s, expected %s".printf (a, z.is_natural () ? "true" : "false", expected ? "true" : "false"));
 710             return;
 711         }
 712     }
 713
 714     pass ();
 715 }
 716
 717 private void test_is_complex ()
 718 {
 719     for (var a = -10; a <= 10; a++)
 720     {
 721         for (var b = -10; b <= 10; b++)
 722         {
 723             var z = new Number.complex (new Number.integer (a), new Number.integer (b));
 724             var expected = b != 0;
 725             if (z.is_complex () != expected)
 726             {
 727                 fail ("(%d+%di).is_complex () -> %s, expected %s".printf (a, b, z.is_complex () ? "true" : "false", expected ? "true" : "false"));
 728                 return;
 729             }
 730         }
 731     }
 732
 733     pass ();
 734 }
 735
 736 private void test_factorial ()
 737 {
 738     for (var a = 0; a <= 10; a++)
 739     {
 740         var z = new Number.integer (a);
 741         var expected = 1;
 742         for (var i = 2; i <= a; i++)
 743             expected *= i;
 744         if (z.factorial ().to_integer () != expected)
 745         {
 746             fail ("(%d).factorial () -> %lli, expected %lli".printf (a, z.factorial ().to_integer (), expected));
 747             return;
 748         }
 749     }
 750
 751     pass ();
 752 }
 753
 754 private void test_add ()
 755 {
 756     for (var a = -10; a <= 10; a++)
 757     {
 758         for (var b = -10; b <= 10; b++)
 759         {
 760             var z = (new Number.integer (a)).add (new Number.integer (b));
 761             var expected = a + b;
 762             if (z.to_integer () != expected)
 763             {
 764                 fail ("(%d).add (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
 765                 return;
 766             }
 767         }
 768     }
 769
 770     pass ();
 771 }
 772
 773 private void test_subtract ()
 774 {
 775     for (var a = -10; a <= 10; a++)
 776     {
 777         for (var b = -10; b <= 10; b++)
 778         {
 779             var z = (new Number.integer (a)).subtract (new Number.integer (b));
 780             var expected = a - b;
 781             if (z.to_integer () != expected)
 782             {
 783                 fail ("(%d).subtract (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
 784                 return;
 785             }
 786         }
 787     }
 788
 789     pass ();
 790 }
 791
 792 private void test_multiply ()
 793 {
 794     for (var a = -10; a <= 10; a++)
 795     {
 796         for (var b = -10; b <= 10; b++)
 797         {
 798             var z = (new Number.integer (a)).multiply (new Number.integer (b));
 799             var expected = a * b;
 800             if (z.to_integer () != expected)
 801             {
 802                 fail ("(%d).multiply (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
 803                 return;
 804             }
 805         }
 806     }
 807
 808     pass ();
 809 }
 810
 811 private void test_multiply_integer ()
 812 {
 813     for (var a = -10; a <= 10; a++)
 814     {
 815         for (var b = -10; b <= 10; b++)
 816         {
 817             var z = (new Number.integer (a)).multiply_integer (b);
 818             var expected = a * b;
 819             if (z.to_integer () != expected)
 820             {
 821                 fail ("(%d).multiply_integer (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
 822                 return;
 823             }
 824         }
 825     }
 826
 827     pass ();
 828 }
 829
 830 private void test_divide ()
 831 {
 832     for (var a = -10; a <= 10; a++)
 833     {
 834         for (var b = -10; b <= 10; b++)
 835         {
 836             if (b == 0)
 837                 continue;
 838
 839             var z = (new Number.integer (a * b)).divide (new Number.integer (b));
 840             var expected = a;
 841             if (z.to_integer () != expected)
 842             {
 843                 fail ("(%d).divide (%d) -> %lli, expected %d".printf (a * b, b, z.to_integer (), expected));
 844                 return;
 845             }
 846         }
 847     }
 848
 849     pass ();
 850 }
 851
 852 private void test_divide_integer ()
 853 {
 854     for (var a = -10; a <= 10; a++)
 855     {
 856         for (var b = -10; b <= 10; b++)
 857         {
 858             if (b == 0)
 859                 continue;
 860
 861             var z = (new Number.integer (a * b)).divide_integer (b);
 862             var expected = a;
 863             if (z.to_integer () != expected)
 864             {
 865                 fail ("(%d).divide_integer (%d) -> %lli, expected %d".printf (a * b, b, z.to_integer (), expected));
 866                 return;
 867             }
 868         }
 869     }
 870
 871     pass ();
 872 }
 873
 874 private void test_modulus_divide ()
 875 {
 876     for (var a = 0; a <= 10; a++)
 877     {
 878         for (var b = 1; b <= 10; b++)
 879         {
 880             var z = (new Number.integer (a)).modulus_divide (new Number.integer (b));
 881             var expected = a % b;
 882             if (z.to_integer () != expected)
 883             {
 884                 fail ("(%d).modulus_divide (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
 885                 return;
 886             }
 887         }
 888     }
 889
 890     pass ();
 891 }
 892
 893 static void test_sin ()
 894 {
 895     for (var a = -Math.PI; a <= Math.PI; a += Math.PI / 16)
 896     {
 897         var z = new Number.double (a).sin ();
 898         var expected = Math.sin (a);
 899         if (!double_matches (z, expected))
 900         {
 901             fail ("(%f).sin () -> %f, expected %f".printf (a, z.to_double (), expected));
 902             return;
 903         }
 904     }
 905
 906     pass ();
 907 }
 908
 909 static void test_cos ()
 910 {
 911     for (var a = -Math.PI; a <= Math.PI; a += Math.PI / 16)
 912     {
 913         var z = new Number.double (a).cos ();
 914         var expected = Math.cos (a);
 915         if (!double_matches (z, expected))
 916         {
 917             fail ("(%f).cos () -> %f, expected %f".printf (a, z.to_double (), expected));
 918             return;
 919         }
 920     }
 921
 922     pass ();
 923 }
 924
 925 private void test_and ()
 926 {
 927     for (var a = 0; a < 10; a++)
 928     {
 929         for (var b = 0; b < 10; b++)
 930         {
 931             var z = (new Number.integer (a)).and (new Number.integer (b));
 932             var expected = a & b;
 933             if (z.to_integer () != expected)
 934             {
 935                 fail ("(%d).and (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
 936                 return;
 937             }
 938         }
 939     }
 940
 941     pass ();
 942 }
 943
 944 private void test_or ()
 945 {
 946     for (var a = 0; a < 10; a++)
 947     {
 948         for (var b = 0; b < 10; b++)
 949         {
 950             var z = (new Number.integer (a)).or (new Number.integer (b));
 951             var expected = a | b;
 952             if (z.to_integer () != expected)
 953             {
 954                 fail ("(%d).or (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
 955                 return;
 956             }
 957         }
 958     }
 959
 960     pass ();
 961 }
 962
 963 private void test_xor ()
 964 {
 965     for (var a = 0; a < 10; a++)
 966     {
 967         for (var b = 0; b < 10; b++)
 968         {
 969             var z = (new Number.integer (a)).xor (new Number.integer (b));
 970             var expected = a ^ b;
 971             if (z.to_integer () != expected)
 972             {
 973                 fail ("(%d).xor (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
 974                 return;
 975             }
 976         }
 977     }
 978
 979     pass ();
 980 }
 981
 982 private void test_not ()
 983 {
 984     for (var a = 0; a < 10; a++)
 985     {
 986         var z = (new Number.integer (a)).not (8);
 987         var expected = ~a & 0xFF;
 988         if (z.to_integer () != expected)
 989         {
 990             fail ("(%d).not () -> %lli, expected %d".printf (a, z.to_integer (), expected));
 991             return;
 992         }
 993     }
 994
 995     pass ();
 996 }
 997
 998 private void test_shift ()
 999 {
1000     for (var a = 0; a < 10; a++)
1001     {
1002         for (var b = -10; b < 10; b++)
1003         {
1004             var z = (new Number.integer (a)).shift (b);
1005             var expected = a << b;
1006             if (b < 0)
1007                 expected = a >> -b;
1008             if (z.to_integer () != expected)
1009             {
1010                 fail ("(%d).shift (%d) -> %lli, expected %d".printf (a, b, z.to_integer (), expected));
1011                 return;
1012             }
1013         }
1014     }
1015
1016     pass ();
1017 }
1018
1019 private void test_factorize ()
1020 {
1021     for (var a = 0; a < 100; a++)
1022     {
1023         var factors = (new Number.integer (a)).factorize ();
1024         var expected = factorize (a);
1025
1026         var matches = false;
1027         if (factors.length () == expected.length ())
1028         {
1029             matches = true;
1030             for (var i = 0 ; i < factors.length (); i++)
1031                 if (factors.nth_data (i).to_integer () != expected.nth_data (i))
1032                     matches = false;
1033         }
1034
1035         if (!matches)
1036         {
1037             var factors_string = "";
1038             foreach (var f in factors)
1039             {
1040                 if (factors_string != "")
1041                     factors_string += ", ";
1042                 factors_string += "%d".printf ((int) f.to_integer ());
1043             }
1044             var expected_string = "";
1045             foreach (var f in expected)
1046             {
1047                 if (expected_string != "")
1048                     expected_string += ", ";
1049                 expected_string += "%d".printf (f);
1050             }
1051             fail ("(%d).factorize () -> (%s), expected (%s)".printf (a, factors_string, expected_string));
1052             return;
1053         }
1054     }
1055
1056     pass ();
1057 }
1058
1059 private List<int> factorize (int number)
1060 {
1061     var factors = new List<int> ();
1062     if (number < 2)
1063     {
1064         factors.append (number);
1065         return factors;
1066     }
1067
1068     var n = number;
1069     while (true)
1070     {
1071         for (var factor = 2; factor <= n; factor++)
1072         {
1073             if (n % factor == 0)
1074             {
1075                 factors.append (factor);
1076                 n /= factor;
1077                 if (n == 1)
1078                     return factors;
1079                 break;
1080             }
1081         }
1082     }
1083 }
1084
1085 static int main (string[] args)
1086 {
1087     Intl.setlocale (LocaleCategory.ALL, "C");
1088
1089     test_integer ();
1090     test_unsigned_integer ();
1091     test_fraction ();
1092     test_float ();
1093     test_double ();
1094     test_complex ();
1095     test_polar ();
1096     test_string ();
1097     test_eulers ();
1098     test_i ();
1099     test_pi ();
1100     //test_random ();
1101     test_is_zero ();
1102     test_is_negative ();
1103     test_is_integer ();
1104     test_is_positive_integer ();
1105     test_is_natural ();
1106     test_is_complex ();
1107     test_sgn ();
1108     test_invert_sign ();
1109     test_abs ();
1110     test_arg ();
1111     test_conjugate ();
1112     test_real_component ();
1113     test_imaginary_component ();
1114     test_integer_component ();
1115     test_fractional_component ();
1116     test_fractional_part ();
1117     test_floor ();
1118     test_ceiling ();
1119     test_round ();
1120     test_reciprocal ();
1121     test_epowy ();
1122     test_xpowy ();
1123     test_xpowy_integer ();
1124     test_root3 (); // FIXME: should check other roots
1125     test_sqrt ();
1126     test_ln ();
1127     test_logarithm2 (); // FIXME: Should check other bases
1128     test_logarithm10 (); // FIXME: Should check other bases
1129     test_factorial ();
1130     test_add ();
1131     test_subtract ();
1132     test_multiply ();
1133     test_multiply_integer ();
1134     test_divide ();
1135     test_divide_integer ();
1136     test_modulus_divide ();
1137     test_sin ();
1138     test_cos ();
1139     //test_tan ();
1140     //test_asin ();
1141     //test_acos ();
1142     //test_atan ();
1143     //test_sinh ();
1144     //test_cosh ();
1145     //test_tanh ();
1146     //test_asinh ();
1147     //test_acosh ();
1148     //test_atanh ();
1149     test_and ();
1150     test_or ();
1151     test_xor ();
1152     test_not ();
1153     //test_mask ();
1154     test_shift ();
1155     //test_ones_complement ();
1156     //test_twos_complement ();
1157     test_factorize ();
1158
1159     if (fail_count == 0)
1160         stdout.printf ("Passed all %i tests\n", pass_count);
1161     else
1162         stdout.printf ("Failed %i/%d tests\n", fail_count, pass_count + fail_count);
1163
1164     return fail_count;
1165 }