src/ops/math.ops

   1 /*
   2  * $Id$
   3 ** math.ops
   4 */
   5
   6 VERSION = PARROT_VERSION;
   7
   8 =head1 NAME
   9
  10 math.ops - Mathematical Operations
  11
  12 =cut
  13
  14 =head1 DESCRIPTION
  15
  16 Operations that perform some sort of mathematics, including both basic
  17 math and transcendental functions.
  18
  19 The variants with a prepended B<n_> like <n_abs> generate a new target PMC.
  20 If possible, they use the appropriate language type, specified with C<.HLL>.
  21
  22 =head2 General infix operations
  23
  24 These operations take an infix operation number and PMC arguments.
  25
  26 =over 4
  27
  28 =item B<infix>(inconst INT, invar PMC, in INT)
  29
  30 =item B<infix>(inconst INT, invar PMC, in NUM)
  31
  32 =item B<infix>(inconst INT, invar PMC, in STR)
  33
  34 =item B<infix>(inconst INT, invar PMC, invar PMC)
  35
  36 General inplace infix dispatch opcode. $1 is the MMD function number.
  37
  38 =item B<infix>(inconst INT, out PMC, invar PMC, in INT)
  39
  40 =item B<infix>(inconst INT, out PMC, invar PMC, in NUM)
  41
  42 =item B<infix>(inconst INT, out PMC, invar PMC, in STR)
  43
  44 =item B<infix>(inconst INT, out PMC, invar PMC, invar PMC)
  45
  46 General infix dispatch opcode. $1 is the MMD function number.
  47
  48 =item B<n_infix>(inconst INT, out PMC, invar PMC, in INT)
  49
  50 =item B<n_infix>(inconst INT, out PMC, invar PMC, in NUM)
  51
  52 =item B<n_infix>(inconst INT, out PMC, invar PMC, in STR)
  53
  54 =item B<n_infix>(inconst INT, out PMC, invar PMC, invar PMC)
  55
  56 General infix dispatch opcode. $1 is the MMD function number.
  57 These opcodes return a new result PMC $2.
  58
  59 =cut
  60
  61 inline op infix(inconst INT, invar PMC, in INT) :base_core {
  62   mmd_dispatch_v_pi(interp, $2, $3, $1);
  63 }
  64
  65 inline op infix(inconst INT, invar PMC, in NUM) :base_core {
  66   mmd_dispatch_v_pn(interp, $2, $3, $1);
  67 }
  68
  69 inline op infix(inconst INT, invar PMC, in STR) :base_core {
  70   mmd_dispatch_v_ps(interp, $2, $3, $1);
  71 }
  72
  73 inline op infix(inconst INT, invar PMC, invar PMC) :base_core {
  74   mmd_dispatch_v_pp(interp, $2, $3, $1);
  75 }
  76
  77 inline op infix(inconst INT, out PMC, invar PMC, in INT) :base_core {
  78   $2 = mmd_dispatch_p_pip(interp, $3, $4, $2, $1);
  79 }
  80
  81 inline op infix(inconst INT, out PMC, invar PMC, in NUM) :base_core {
  82   $2 = mmd_dispatch_p_pnp(interp, $3, $4, $2, $1);
  83 }
  84
  85 inline op infix(inconst INT, out PMC, invar PMC, in STR) :base_core {
  86   $2 = mmd_dispatch_p_psp(interp, $3, $4, $2, $1);
  87 }
  88
  89 inline op infix(inconst INT, out PMC, invar PMC, invar PMC) :base_core {
  90   $2 = mmd_dispatch_p_ppp(interp, $3, $4, $2, $1);
  91 }
  92
  93 inline op n_infix(inconst INT, out PMC, invar PMC, in INT) :base_core {
  94   $2 = mmd_dispatch_p_pip(interp, $3, $4, NULL, $1);
  95 }
  96
  97 inline op n_infix(inconst INT, out PMC, invar PMC, in NUM) :base_core {
  98   $2 = mmd_dispatch_p_pnp(interp, $3, $4, NULL, $1);
  99 }
 100
 101 inline op n_infix(inconst INT, out PMC, invar PMC, in STR) :base_core {
 102   $2 = mmd_dispatch_p_psp(interp, $3, $4, NULL, $1);
 103 }
 104
 105 inline op n_infix(inconst INT, out PMC, invar PMC, invar PMC) :base_core {
 106   $2 = mmd_dispatch_p_ppp(interp, $3, $4, NULL, $1);
 107 }
 108 ###############################################################################
 109
 110 =back
 111
 112 =head2 Arithmetic operations
 113
 114 These operations store the results of arithmetic on other registers and
 115 constants into their destination register, $1.
 116
 117 =over 4
 118
 119 =cut
 120
 121 ########################################
 122
 123 =item B<abs>(inout INT)
 124
 125 =item B<abs>(inout NUM)
 126
 127 =item B<abs>(invar PMC)
 128
 129 Set $1 to its absolute value.
 130
 131 =item B<abs>(out INT, in INT)
 132
 133 =item B<abs>(out NUM, in NUM)
 134
 135 =item B<abs>(out PMC, invar PMC)
 136
 137 Set $1 to absolute value of $2.
 138
 139 =item B<n_abs>(out PMC, invar PMC)
 140
 141 Create new $1 as the absolute of $2.
 142
 143 =cut
 144
 145 inline op abs(inout INT) :base_core {
 146   $1 = abs($1);
 147 }
 148
 149 inline op abs(inout NUM) :base_core {
 150   $1 = fabs($1);
 151 }
 152
 153 inline op abs(out INT, in INT) :base_core {
 154   if ($2 < 0)
 155     $1 = - (INTVAL)$2;
 156   else
 157     $1 = (INTVAL)$2;
 158 }
 159
 160 inline op abs(out NUM, in NUM) :base_core {
 161   if ($2 < 0)
 162     $1 = - (FLOATVAL)$2;
 163   else
 164     $1 = (FLOATVAL)$2;
 165 }
 166
 167 inline op abs(invar PMC) :base_core {
 168   VTABLE_i_absolute(interp, $1);
 169 }
 170
 171 inline op abs(out PMC, invar PMC) :base_core {
 172   $1 = VTABLE_absolute(interp, $2, $1);
 173 }
 174
 175 inline op n_abs(out PMC, invar PMC) :base_core {
 176   $1 = VTABLE_absolute(interp, $2, NULL);
 177 }
 178
 179 ########################################
 180
 181 =item B<add>(inout INT, in INT)
 182
 183 =item B<add>(inout NUM, in NUM)
 184
 185 Increase $1 by the amount in $2.
 186
 187 =item B<add>(out INT, in INT, in INT)
 188
 189 =item B<add>(out NUM, in NUM, in NUM)
 190
 191 Set $1 to the sum of $2 and $3.
 192
 193 Please note that all PMC variants of all infix functions are handled
 194 by the C<infix> and C<n_infix> opcodes. Thus there is no distinct implementation
 195 of e.g. C<add_p_p_p>.
 196
 197 =cut
 198
 199 inline op add(inout INT, in INT) :base_core {
 200   $1 += $2;
 201 }
 202
 203 inline op add(inout NUM, in NUM) :base_core {
 204   $1 += $2;
 205 }
 206
 207 inline op add(out INT, in INT, in INT) :base_core {
 208   $1 = $2 + $3;
 209 }
 210
 211 inline op add(out NUM, in NUM, in NUM) :base_core {
 212   $1 = $2 + $3;
 213 }
 214
 215 ########################################
 216
 217 =item B<cmod>(out INT, in INT, in INT)
 218
 219 NOTE: This "uncorrected mod" algorithm uses the C language's built-in
 220 mod operator (x % y), which is
 221
 222     ... the remainder when x is divided by y, and thus is zero
 223     when y divides x exactly.
 224     ...
 225     The direction of truncation for / and the sign of the result
 226     for % are machine-dependent for negative operands, as is the
 227     action taken on overflow or underflow.
 228                                                      -- [1], page 41
 229
 230 Also:
 231
 232     ... if the second operand is 0, the result is undefined.
 233     Otherwise, it is always true that (a/b)*b + a%b is equal to z. If
 234     both operands are non-negative, then the remainder is non-
 235     negative and smaller than the divisor; if not, it is guaranteed
 236     only that the absolute value of the remainder is smaller than
 237     the absolute value of the divisor.
 238                                                      -- [1], page 205
 239
 240 This op is provided for those who need it (such as speed-sensitive
 241 applications with heavy use of mod, but using it only with positive
 242 arguments), but a more mathematically useful mod based on ** floor(x/y)
 243 and defined with y == 0 is provided by the mod op.
 244
 245   [1] Brian W. Kernighan and Dennis M. Ritchie, *The C Programming
 246       Language*, Second Edition. Prentice Hall, 1988.
 247
 248 If the denominator is zero, a 'Divide by zero' exception is thrown.
 249
 250 =cut
 251
 252 inline op cmod(out INT, in INT, in INT) :base_core {
 253   INTVAL den = $3;
 254   if ($3 == 0)
 255     real_exception(interp, NULL, E_ZeroDivisionError,
 256                     "Divide by zero");
 257   $1 = $2 % den;
 258 }
 259
 260 ########################################
 261
 262 =item B<cmod>(out NUM, in NUM, in NUM)
 263
 264 NOTE: This "uncorrected mod" algorithm uses the built-in C math library's
 265 fmod() function, which computes
 266
 267     ... the remainder of dividing x by y. The return value is
 268     x - n * y, where n is the quotient of x / y, rounded towards
 269     zero to an integer.
 270                                 -- fmod() manpage on RedHat Linux 7.0
 271
 272 In addition, fmod() returns
 273
 274     the remainder, unless y is zero, when the function fails and
 275     errno is set.
 276
 277 According to page 251 of [1], the result when y is zero is implementation-
 278 defined.
 279
 280 This op is provided for those who need it, but a more mathematically
 281 useful numeric mod based on floor(x/y) instead of truncate(x/y) and
 282 defined with y == 0 is provided by the mod op.
 283
 284   [1] Brian W. Kernighan and Dennis M. Ritchie, *The C Programming
 285       Language*, Second Edition. Prentice Hall, 1988.
 286
 287 If the denominator is zero, a 'Divide by zero' exception is thrown.
 288
 289 =cut
 290
 291 inline op cmod(out NUM, in NUM, in NUM) :base_core {
 292   FLOATVAL den = $3;
 293   if (FLOAT_IS_ZERO($3))
 294     real_exception(interp, NULL, E_ZeroDivisionError,
 295                     "Divide by zero");
 296   $1 = fmod($2, den);
 297 }
 298
 299 ########################################
 300
 301 =item B<dec>(inout INT)
 302
 303 =item B<dec>(inout NUM)
 304
 305 =item B<dec>(invar PMC)
 306
 307 Decrease $1 by one.
 308
 309 =cut
 310
 311 inline op dec(inout INT) :base_core {
 312   $1--;
 313 }
 314
 315 inline op dec(inout NUM) :base_core {
 316   $1--;
 317 }
 318
 319 inline op dec(invar PMC) :base_core {
 320   VTABLE_decrement(interp, $1);
 321 }
 322
 323 ########################################
 324
 325 =item B<div>(inout INT, in INT)
 326
 327 =item B<div>(inout NUM, in NUM)
 328
 329 Divide $1 by $2.
 330
 331 =item B<div>(out INT, in INT, in INT)
 332
 333 =item B<div>(out NUM, in NUM, in NUM)
 334
 335 Set $1 to the quotient of $2 divided by $3. In the case of INTVAL division, the
 336 result is truncated (NOT rounded or floored).
 337 If the denominator is zero, a 'Divide by zero' exception is thrown.
 338
 339 =cut
 340
 341 inline op div(inout INT, in INT) :base_core {
 342   INTVAL den = $2;
 343   if ($2 == 0)
 344     real_exception(interp, NULL, E_ZeroDivisionError,
 345                     "Divide by zero");
 346   $1 /= den;
 347 }
 348
 349 inline op div(inout NUM, in NUM) :base_core {
 350   FLOATVAL den = $2;
 351   if (FLOAT_IS_ZERO($2))
 352     real_exception(interp, NULL, E_ZeroDivisionError,
 353                     "Divide by zero");
 354   $1 /= den;
 355 }
 356
 357 inline op div(out INT, in INT, in INT) :base_core {
 358   INTVAL den = $3;
 359   if ($3 == 0)
 360     real_exception(interp, NULL, E_ZeroDivisionError,
 361                     "Divide by zero");
 362   $1 = $2 / den;
 363 }
 364
 365 inline op div(out NUM, in NUM, in NUM) :base_core {
 366   FLOATVAL den = $3;
 367   if (FLOAT_IS_ZERO($3))
 368     real_exception(interp, NULL, E_ZeroDivisionError,
 369                     "Divide by zero");
 370   $1 = $2 / den;
 371 }
 372
 373 =item B<fdiv>(inout INT, in INT)
 374
 375 =item B<fdiv>(inout NUM, in NUM)
 376
 377 Floor divide $1 by $2.
 378
 379 =item B<fdiv>(out INT, in INT, in INT)
 380
 381 =item B<fdiv>(out NUM, in NUM, in NUM)
 382
 383 Set $1 to the quotient of $2 divided by $3. The result is the floor()
 384 of the division i.e. the next whole integer towards -inf.
 385 If the denominator is zero, a 'Divide by zero' exception is thrown.
 386
 387 =cut
 388
 389 inline op fdiv(inout INT, in INT) :base_core {
 390   INTVAL   den = $2;
 391   FLOATVAL f;
 392
 393   if ($2 == 0)
 394     real_exception(interp, NULL, E_ZeroDivisionError,
 395                     "Divide by zero");
 396
 397   f  = floor($1 / den);
 398   $1 = (INTVAL)f;
 399 }
 400
 401 inline op fdiv(inout NUM, in NUM) :base_core {
 402   FLOATVAL den = $2;
 403   if (FLOAT_IS_ZERO($2))
 404     real_exception(interp, NULL, E_ZeroDivisionError,
 405                     "Divide by zero");
 406   $1 = floor($1 / den);
 407 }
 408
 409 inline op fdiv(out INT, in INT, in INT) :base_core {
 410   INTVAL   den = $3;
 411   FLOATVAL f;
 412
 413   if ($3 == 0)
 414     real_exception(interp, NULL, E_ZeroDivisionError,
 415                     "Divide by zero");
 416
 417   f  = floor($2 / den);
 418   $1 = (INTVAL)f;
 419 }
 420
 421 inline op fdiv(out NUM, in NUM, in NUM) :base_core {
 422   FLOATVAL den = $3;
 423   if (FLOAT_IS_ZERO($3))
 424     real_exception(interp, NULL, E_ZeroDivisionError,
 425                     "Divide by zero");
 426   $1 = floor($2 / den);
 427 }
 428
 429 ########################################
 430
 431 =item B<ceil>(inout NUM)
 432
 433 Set $1 to the smallest integral value greater than or equal to $1.
 434
 435 =item B<ceil>(out INT, in NUM)
 436
 437 =item B<ceil>(out NUM, in NUM)
 438
 439 Set $1 to the smallest integral value greater than or equal to $2.
 440
 441 =cut
 442
 443 inline op ceil(inout NUM) :base_core {
 444   $1 = ceil($1);
 445 }
 446
 447 inline op ceil(out INT, in NUM) :base_core {
 448   FLOATVAL f = ceil($2);
 449   $1         = (INTVAL)f;
 450 }
 451
 452 inline op ceil(out NUM, in NUM) :base_core {
 453   $1 = ceil($2);
 454 }
 455
 456 ########################################
 457
 458 =item B<floor>(inout NUM)
 459
 460 Set $1 to the largest integral value less than or equal to $1.
 461
 462 =item B<floor>(out INT, in NUM)
 463
 464 =item B<floor>(out NUM, in NUM)
 465
 466 Set $1 to the largest integral value less than or equal to $2.
 467
 468 =cut
 469
 470 inline op floor(inout NUM) :base_core {
 471   $1 = floor($1);
 472 }
 473
 474 inline op floor(out INT, in NUM) :base_core {
 475   FLOATVAL f = floor($2);
 476   $1         = (INTVAL)f;
 477 }
 478
 479 inline op floor(out NUM, in NUM) :base_core {
 480   $1 = floor($2);
 481 }
 482
 483 ########################################
 484
 485 =item B<inc>(inout INT)
 486
 487 =item B<inc>(inout NUM)
 488
 489 =item B<inc>(invar PMC)
 490
 491 Increase $1 by one.
 492
 493 =cut
 494
 495 inline op inc(inout INT) :base_core {
 496   $1++;
 497 }
 498
 499 inline op inc(inout NUM) :base_core {
 500   $1++;
 501 }
 502
 503 inline op inc(invar PMC) :base_core {
 504   VTABLE_increment(interp, $1);
 505 }
 506
 507
 508 ########################################
 509
 510 =item B<mod>(out INT, in INT, in INT)
 511
 512 =item B<mod>(out NUM, in NUM, in NUM)
 513
 514 Sets $1 to the modulus of $2 and $3.
 515
 516 =item B<mod>(inout INT, in INT)
 517
 518 =item B<mod>(inout NUM, in NUM)
 519
 520 Sets $1 to the modulus of $1 and $2.
 521
 522
 523 NOTE: This "corrected mod" algorithm is based on the C code on page 70
 524 of [1]. Assuming correct behavior of the built-in mod operator (%) with
 525 positive arguments, this algorithm implements a mathematically convenient
 526 version of mod, defined thus:
 527
 528   x mod y = x - y * floor(x / y)
 529
 530 For more information on this definition of mod, see section 3.4 of [2],
 531 pages 81-85.
 532
 533 References:
 534
 535   [1] Donald E. Knuth, *MMIXware: A RISC Computer for the Third
 536       Millennium* Springer, 1999.
 537
 538   [2] Ronald L. Graham, Donald E. Knuth and Oren Patashnik, *Concrete
 539       Mathematics*, Second Edition. Addison-Wesley, 1994.
 540
 541 =cut
 542
 543 op mod(inout INT, in INT) :base_core {
 544   $1 = intval_mod($1, $2);
 545 }
 546
 547 op mod(out INT, in INT, in INT) :base_core {
 548   $1 = intval_mod($2, $3);
 549 }
 550
 551 op mod(out NUM, in NUM, in NUM) :base_core {
 552   $1 = floatval_mod($2, $3);
 553 }
 554
 555 op mod(inout NUM, in NUM) :base_core {
 556   $1 = floatval_mod($1, $2);
 557 }
 558
 559 ########################################
 560
 561 =item B<mul>(inout INT, in INT)
 562
 563 =item B<mul>(inout NUM, in NUM)
 564
 565 Set $1 to the product of $1 and $2.
 566
 567 =item B<mul>(out INT, in INT, in INT)
 568
 569 =item B<mul>(out NUM, in NUM, in NUM)
 570
 571 Set $1 to the product of $2 and $3.
 572
 573 =cut
 574
 575 inline op mul(inout INT, in INT) :base_core {
 576   $1 *= $2;
 577 }
 578
 579 inline op mul(inout NUM, in NUM) :base_core {
 580   $1 *= $2;
 581 }
 582
 583 inline op mul(out INT, in INT, in INT) :base_core {
 584   $1 = $2 * $3;
 585 }
 586
 587 inline op mul(out NUM, in NUM, in NUM) :base_core {
 588   $1 = $2 * $3;
 589 }
 590
 591 ########################################
 592
 593 =item B<neg>(inout INT)
 594
 595 =item B<neg>(inout NUM)
 596
 597 =item B<neg>(invar PMC)
 598
 599 Set $1 to its negative.
 600
 601 =item B<neg>(out INT, in INT)
 602
 603 =item B<neg>(out NUM, in NUM)
 604
 605 =item B<neg>(out PMC, invar PMC)
 606
 607 Set $1 to the negative of $2.
 608
 609 =item B<n_neg>(out PMC, invar PMC)
 610
 611 Create $1 as the negative of $2.
 612
 613 =cut
 614
 615 inline op neg(inout INT) :base_core {
 616   $1 = - $1;
 617 }
 618
 619 inline op neg(inout NUM) :base_core {
 620   $1 = - $1;
 621 }
 622
 623 inline op neg(invar PMC) :base_core {
 624   VTABLE_i_neg(interp, $1);
 625 }
 626
 627 inline op neg(out INT, in INT) :base_core {
 628   $1 = - $2;
 629 }
 630
 631 inline op neg(out NUM, in NUM) :base_core {
 632   $1 = - $2;
 633 }
 634
 635 inline op neg(out PMC, invar PMC) :base_core {
 636   $1 = VTABLE_neg(interp, $2, $1);
 637 }
 638
 639 inline op n_neg(out PMC, invar PMC) :base_core {
 640   $1 = VTABLE_neg(interp, $2, NULL);
 641 }
 642
 643 ########################################
 644
 645 =item B<pow>(out NUM, in NUM, in NUM)
 646
 647 Set $1 to $2 raised to the power $3.
 648
 649 =cut
 650
 651 inline op pow(out NUM, in NUM, in NUM) :base_core {
 652    $1 = pow((FLOATVAL)$2, (FLOATVAL)$3);
 653 }
 654
 655 ########################################
 656
 657 =item B<sub>(inout INT, in INT)
 658
 659 =item B<sub>(inout NUM, in NUM)
 660
 661 Decrease $1 by the amount in $2.
 662
 663 =item B<sub>(out INT, in INT, in INT)
 664
 665 =item B<sub>(out NUM, in NUM, in NUM)
 666
 667 Set $1 to $2 minus $3.
 668
 669 =cut
 670
 671 inline op sub(inout INT, in INT) :base_core {
 672   $1 -= $2;
 673 }
 674
 675 inline op sub(inout NUM, in NUM) :base_core {
 676   $1 -= $2;
 677 }
 678
 679 inline op sub(out INT, in INT, in INT) :base_core {
 680   $1 = $2 - $3;
 681 }
 682
 683 inline op sub(out NUM, in NUM, in NUM) :base_core {
 684   $1 = $2 - $3;
 685 }
 686
 687 ########################################
 688
 689 =item B<sqrt>(out NUM, in NUM)
 690
 691 Set $1 to the square root of $2.
 692
 693 =cut
 694
 695 inline op sqrt(out NUM, in NUM) :base_core {
 696   $1 = sqrt((FLOATVAL)$2);
 697 }
 698
 699 =back
 700
 701 =cut
 702
 703
 704
 705 ###############################################################################
 706
 707 =head2 Transcendental mathematical operations
 708
 709 These operations perform various transcendental operations such as logarithmics
 710 and trigonometrics.
 711
 712 =over 4
 713
 714 =cut
 715
 716 ########################################
 717
 718 =item B<acos>(out NUM, in NUM)
 719
 720 Set $1 to the arc cosine (in radians) of $2.
 721
 722 =cut
 723
 724 inline op acos(out NUM, in NUM) :base_math {
 725   $1 = acos((FLOATVAL)$2);
 726 }
 727
 728 ########################################
 729
 730 =item B<asec>(out NUM, in NUM)
 731
 732 Set $1 to the arc secant (in radians) of $2.
 733
 734 =cut
 735
 736 inline op asec(out NUM, in NUM) :base_math {
 737   $1 = acos(((FLOATVAL)1) / ((FLOATVAL)$2));
 738 }
 739
 740 ########################################
 741
 742
 743 =item B<asin>(out NUM, in NUM)
 744
 745 Set $1 to the arc sine (in radians) of $2.
 746
 747 =cut
 748
 749 inline op asin(out NUM, in NUM) :base_math {
 750   $1 = asin((FLOATVAL)$2);
 751 }
 752
 753 ########################################
 754
 755 =item B<atan>(out NUM, in NUM)
 756
 757 =item B<atan>(out NUM, in NUM, in NUM)
 758
 759 The two-argument versions set $1 to the arc tangent (in radians) of $2.
 760
 761 The three-argument versions set $1 to the arc tangent (in radians) of
 762 $2 / $3, taking account of the signs of the arguments in determining the
 763 quadrant of the result.
 764
 765 =cut
 766
 767 inline op atan(out NUM, in NUM) :base_math {
 768   $1 = atan((FLOATVAL)$2);
 769 }
 770
 771 inline op atan(out NUM, in NUM, in NUM) :base_math {
 772   $1 = atan2((FLOATVAL)$2, (FLOATVAL)$3);
 773 }
 774
 775 ########################################
 776
 777 =item B<cos>(out NUM, in NUM)
 778
 779 Set $1 to the cosine of $2 (given in radians).
 780
 781 =cut
 782
 783 inline op cos(out NUM, in NUM) :base_math {
 784   $1 = cos((FLOATVAL)$2);
 785 }
 786
 787 ########################################
 788
 789 =item B<cosh>(out NUM, in NUM)
 790
 791 Set $1 to the hyperbolic cosine of $2 (given in radians).
 792
 793 =cut
 794
 795 inline op cosh(out NUM, in NUM) :base_math {
 796   $1 = cosh((FLOATVAL)$2);
 797 }
 798
 799 ########################################
 800
 801 =item B<exp>(out NUM, in NUM)
 802
 803 Set $1 to I<e> raised to the power $2. I<e> is the base of the natural
 804 logarithm.
 805
 806 =cut
 807
 808 inline op exp(out NUM, in NUM) :base_math {
 809   $1 = exp((FLOATVAL)$2);
 810 }
 811
 812 ########################################
 813
 814 =item B<ln>(out NUM, in NUM)
 815
 816 Set $1 to the natural (base I<e>) logarithm of $2.
 817
 818 =cut
 819
 820 inline op ln(out NUM, in NUM) :base_math {
 821   $1 = log((FLOATVAL)$2);
 822 }
 823
 824 ########################################
 825
 826 =item B<log10>(out NUM, in NUM)
 827
 828 Set $1 to the base 10 logarithm of $2.
 829
 830 =cut
 831
 832 inline op log10(out NUM, in NUM) :base_math {
 833   $1 = log10((FLOATVAL)$2);
 834 }
 835
 836 ########################################
 837
 838 =item B<log2>(out NUM, in NUM)
 839
 840 Set $1 to the base 2 logarithm of $2.
 841
 842 =cut
 843
 844 op log2(out NUM, in NUM) :base_math {
 845    FLOATVAL temp = log((FLOATVAL)2.0);
 846   $1 = log((FLOATVAL)$2) / temp;
 847 }
 848
 849 ########################################
 850
 851 =item B<sec>(out NUM, in NUM)
 852
 853 Set $1 to the secant of $2 (given in radians).
 854
 855 =cut
 856
 857 inline op sec(out NUM, in NUM) :base_math {
 858   $1 = ((FLOATVAL)1) / cos((FLOATVAL)$2);
 859 }
 860
 861 ########################################
 862
 863 =item B<sech>(out NUM, in NUM)
 864
 865 Set $1 to the hyperbolic secant of $2 (given in radians).
 866
 867 =cut
 868
 869 inline op sech(out NUM, in NUM) :base_math {
 870   $1 = ((FLOATVAL)1) / cosh((FLOATVAL)$2);
 871 }
 872
 873 ########################################
 874
 875 =item B<sin>(out NUM, in NUM)
 876
 877 Set $1 to the sine of $2 (given in radians).
 878
 879 =cut
 880
 881 inline op sin(out NUM, in NUM) :base_math {
 882   $1 = sin((FLOATVAL)$2);
 883 }
 884
 885 ########################################
 886
 887 =item B<sinh>(out NUM, in NUM)
 888
 889 Set $1 to the hyperbolic sine of $2 (given in radians).
 890
 891 =cut
 892
 893 inline op sinh(out NUM, in NUM) :base_math {
 894   $1 = sinh((FLOATVAL)$2);
 895 }
 896
 897 ########################################
 898
 899 =item B<tan>(out NUM, in NUM)
 900
 901 Set $1 to the tangent of $2 (given in radians).
 902
 903 =cut
 904
 905 inline op tan(out NUM, in NUM) :base_math {
 906   $1 = tan((FLOATVAL)$2);
 907 }
 908
 909 ########################################
 910
 911 =item B<tanh>(out NUM, in NUM)
 912
 913 Set $1 to the hyperbolic tangent of $2 (given in radians).
 914
 915 =cut
 916
 917 inline op tanh(out NUM, in NUM) :base_math {
 918   $1 = tanh((FLOATVAL)$2);
 919 }
 920
 921 =back
 922
 923 =cut
 924
 925 ###############################################################################
 926
 927 =head2 Other mathematical operations
 928
 929 Implementations of various mathematical operations
 930
 931 =over 4
 932
 933 =cut
 934
 935 ########################################
 936
 937 =item B<gcd>(out INT, in INT, in INT)
 938
 939 Greatest Common divisor of $2 and $3.
 940
 941 =cut
 942
 943 inline op gcd(out INT, in INT, in INT) :advanced_math {
 944  INTVAL p = 0;
 945  INTVAL a = $2 < 0 ? -$2 : $2;
 946  INTVAL b = $3 < 0 ? -$3 : $3;
 947
 948  if (a==0) { $1=b; goto NEXT(); }
 949  if (b==0) { $1=a; goto NEXT(); }
 950
 951  while (!((a | b) & 1)) {
 952    a>>=1;
 953    b>>=1;
 954    p++;
 955  }
 956
 957  while (a>0) {
 958    if (!(a & 1)) a>>=1;
 959    else if (!(b & 1)) b>>=1;
 960    else if (a<b)      b = (b-a)>>1;
 961    else               a = (a-b)>>1;
 962  }
 963
 964  $1 = b<<p;
 965 }
 966
 967
 968 ########################################
 969
 970 =item B<lcm>(out INT, in INT, in INT)
 971
 972 Least Common Multiple of $2 and $3
 973
 974 =cut
 975
 976 inline op lcm(out INT, in INT, in INT) :advanced_math {
 977  INTVAL gcd = 0;
 978  INTVAL p = 0;
 979  INTVAL a = $2 < 0 ? -$2 : $2;
 980  INTVAL b = $3 < 0 ? -$3 : $3;
 981  INTVAL saved_var1 = a, saved_var2 = b;
 982
 983  if (a==0 || b==0) { $1=0; goto NEXT(); }
 984
 985  while (!((a | b) & 1)) {
 986    a>>=1;
 987    b>>=1;
 988    p++;
 989  }
 990
 991  while (a>0) {
 992    if (!(a & 1)) a>>=1;
 993    else if (!(b & 1)) b>>=1;
 994    else if (a<b)      b = (b-a)>>1;
 995    else               a = (a-b)>>1;
 996  }
 997
 998  gcd = b<<p;
 999  saved_var1 /= gcd;
1000  $1 = saved_var1*saved_var2;
1001 }
1002
1003 ########################################
1004
1005 =item B<fact>(out INT, in INT)
1006
1007 =item B<fact>(out NUM, in INT)
1008
1009 Factorial, n!. Calculates the product of 1 to N.
1010
1011 =cut
1012
1013 inline op fact(out INT, in INT) :advanced_math {
1014   /* Coercing a negative to a UINT can get pretty ugly
1015    * in this situation. */
1016   INTVAL i = $2;
1017   UINTVAL q = 1;
1018   while (i>0) {
1019     q = q*i;
1020     i--;
1021   }
1022   $1 = q;
1023 }
1024
1025 inline op fact(out NUM, in INT) :advanced_math {
1026   /* Coercing a negative to a UINT can get pretty ugly
1027    * in this situation. */
1028   INTVAL i = $2;
1029   FLOATVAL q = 1;
1030   while (i>0) {
1031     q = q*i;
1032     i--;
1033   }
1034   $1 = q;
1035 }
1036
1037 =back
1038
1039 =cut
1040
1041 ###############################################################################
1042
1043 =head1 COPYRIGHT
1044
1045 Copyright (C) 2001-2008, The Perl Foundation.
1046
1047 =head1 LICENSE
1048
1049 This program is free software. It is subject to the same license
1050 as the Parrot interpreter itself.
1051
1052 =cut
1053
1054 /*
1055  * Local variables:
1056  *   c-file-style: "parrot"
1057  * End:
1058  * vim: expandtab shiftwidth=4:
1059  */