src/ops/math.ops

   1 /*
   2  * $Id$
   3 ** math.ops
   4 */
   5
   6 =head1 NAME
   7
   8 math.ops - Mathematical Opcodes
   9
  10 =cut
  11
  12 =head1 DESCRIPTION
  13
  14 Operations that perform basic mathematics. See F<src/dynoplibs/> for more
  15 advanced operations.
  16
  17 When making changes to any ops file, run C<make bootstrap-ops> to regenerate
  18 all generated ops files.
  19
  20 =head2 Arithmetic operations
  21
  22 These operations store the results of arithmetic on other registers and
  23 constants into their destination register, $1.
  24
  25 =over 4
  26
  27 =cut
  28
  29 ########################################
  30
  31 =item B<abs>(inout INT)
  32
  33 =item B<abs>(inout NUM)
  34
  35 =item B<abs>(invar PMC)
  36
  37 Set $1 to its absolute value.
  38
  39 =item B<abs>(out INT, in INT)
  40
  41 =item B<abs>(out NUM, in NUM)
  42
  43 =item B<abs>(out PMC, invar PMC)
  44
  45 Set $1 to absolute value of $2.
  46
  47 =cut
  48
  49 inline op abs(inout INT) :base_core {
  50     $1 = abs($1);
  51 }
  52
  53 inline op abs(inout NUM) :base_core {
  54     $1 = fabs($1);
  55 }
  56
  57 inline op abs(out INT, in INT) :base_core {
  58     $1 = abs($2);
  59 }
  60
  61 inline op abs(out NUM, in NUM) :base_core {
  62     $1 = fabs($2);
  63 }
  64
  65 inline op abs(invar PMC) :base_core {
  66     VTABLE_i_absolute(interp, $1);
  67 }
  68
  69 inline op abs(out PMC, invar PMC) :base_core {
  70     $1 = VTABLE_absolute(interp, $2, $1);
  71 }
  72
  73 ########################################
  74
  75 =item B<add>(inout INT, in INT)
  76
  77 =item B<add>(inout NUM, in NUM)
  78
  79 =item B<add>(invar PMC, invar PMC)
  80
  81 =item B<add>(invar PMC, in INT)
  82
  83 =item B<add>(invar PMC, in NUM)
  84
  85 Increase $1 by the amount in $2.
  86
  87 =item B<add>(out INT, in INT, in INT)
  88
  89 =item B<add>(out NUM, in NUM, in NUM)
  90
  91 =item B<add>(invar PMC, invar PMC, invar PMC)
  92
  93 =item B<add>(invar PMC, invar PMC, in INT)
  94
  95 =item B<add>(invar PMC, invar PMC, in NUM)
  96
  97 Set $1 to the sum of $2 and $3.
  98
  99 =cut
 100
 101 inline op add(inout INT, in INT) :base_core {
 102     $1 += $2;
 103 }
 104
 105 inline op add(inout NUM, in NUM) :base_core {
 106     $1 += $2;
 107 }
 108
 109 inline op add(invar PMC, invar PMC) :base_core {
 110     VTABLE_i_add(interp, $1, $2);
 111 }
 112
 113 inline op add(invar PMC, in INT) :base_core {
 114     VTABLE_i_add_int(interp, $1, $2);
 115 }
 116
 117 inline op add(invar PMC, in NUM) :base_core {
 118     VTABLE_i_add_float(interp, $1, $2);
 119 }
 120
 121 inline op add(out INT, in INT, in INT) :base_core {
 122     $1 = $2 + $3;
 123 }
 124
 125 inline op add(out NUM, in NUM, in NUM) :base_core {
 126     $1 = $2 + $3;
 127 }
 128
 129 inline op add(invar PMC, invar PMC, invar PMC) :base_core {
 130     $1 = VTABLE_add(interp, $2, $3, $1);
 131 }
 132
 133 inline op add(invar PMC, invar PMC, in INT) :base_core {
 134     $1 = VTABLE_add_int(interp, $2, $3, $1);
 135 }
 136
 137 inline op add(invar PMC, invar PMC, in NUM) :base_core {
 138     $1 = VTABLE_add_float(interp, $2, $3, $1);
 139 }
 140
 141 ########################################
 142
 143 =item B<dec>(inout INT)
 144
 145 =item B<dec>(inout NUM)
 146
 147 =item B<dec>(invar PMC)
 148
 149 Decrease $1 by one.
 150
 151 =cut
 152
 153 inline op dec(inout INT) :base_core {
 154     $1--;
 155 }
 156
 157 inline op dec(inout NUM) :base_core {
 158     $1--;
 159 }
 160
 161 inline op dec(invar PMC) :base_core {
 162     VTABLE_decrement(interp, $1);
 163 }
 164
 165 ########################################
 166
 167 =item B<div>(inout INT, in INT)
 168
 169 =item B<div>(inout NUM, in NUM)
 170
 171 =item B<div>(invar PMC, invar PMC)
 172
 173 =item B<div>(invar PMC, in INT)
 174
 175 =item B<div>(invar PMC, in NUM)
 176
 177 Divide $1 by $2.
 178
 179 =item B<div>(out INT, in INT, in INT)
 180
 181 =item B<div>(out NUM, in NUM, in NUM)
 182
 183 =item B<div>(invar PMC, invar PMC, invar PMC)
 184
 185 =item B<div>(invar PMC, invar PMC, in INT)
 186
 187 =item B<div>(invar PMC, invar PMC, in NUM)
 188
 189 Set $1 to the quotient of $2 divided by $3. In the case of INTVAL division, the
 190 result is truncated (NOT rounded or floored).
 191 If the denominator is zero, a 'Divide by zero' exception is thrown.
 192
 193 =cut
 194
 195 inline op div(inout INT, in INT) :base_core {
 196     INTVAL den = $2;
 197     if (den == 0) {
 198         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
 199             EXCEPTION_DIV_BY_ZERO,
 200             "Divide by zero");
 201         goto ADDRESS(handler);
 202     }
 203     $1 /= den;
 204 }
 205
 206 inline op div(inout NUM, in NUM) :base_core {
 207     FLOATVAL den = $2;
 208     if (FLOAT_IS_ZERO(den)) {
 209         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
 210             EXCEPTION_DIV_BY_ZERO,
 211             "Divide by zero");
 212         goto ADDRESS(handler);
 213     }
 214     $1 /= den;
 215 }
 216
 217 inline op div(invar PMC, invar PMC) :base_core {
 218     VTABLE_i_divide(interp, $1, $2);
 219 }
 220
 221 inline op div(invar PMC, in INT) :base_core {
 222     VTABLE_i_divide_int(interp, $1, $2);
 223 }
 224
 225 inline op div(invar PMC, in NUM) :base_core {
 226     VTABLE_i_divide_float(interp, $1, $2);
 227 }
 228 inline op div(out INT, in INT, in INT) :base_core {
 229     INTVAL den = $3;
 230     if (den == 0) {
 231         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
 232             EXCEPTION_DIV_BY_ZERO,
 233             "Divide by zero");
 234         goto ADDRESS(handler);
 235     }
 236     $1 = $2 / den;
 237 }
 238
 239 inline op div(out NUM, in NUM, in NUM) :base_core {
 240     FLOATVAL den = $3;
 241     if (FLOAT_IS_ZERO(den)) {
 242         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
 243             EXCEPTION_DIV_BY_ZERO,
 244             "Divide by zero");
 245         goto ADDRESS(handler);
 246     }
 247     $1 = $2 / den;
 248 }
 249
 250 inline op div(invar PMC, invar PMC, invar PMC) :base_core {
 251     $1 = VTABLE_divide(interp, $2, $3, $1);
 252 }
 253
 254 inline op div(invar PMC, invar PMC, in INT) :base_core {
 255     $1 = VTABLE_divide_int(interp, $2, $3, $1);
 256 }
 257
 258 inline op div(invar PMC, invar PMC, in NUM) :base_core {
 259     $1 = VTABLE_divide_float(interp, $2, $3, $1);
 260 }
 261
 262
 263 =item B<fdiv>(inout INT, in INT)
 264
 265 =item B<fdiv>(inout NUM, in NUM)
 266
 267 =item B<fdiv>(invar PMC, invar PMC)
 268
 269 =item B<fdiv>(invar PMC, in INT)
 270
 271 =item B<fdiv>(invar PMC, in NUM)
 272
 273 Floor divide $1 by $2.
 274
 275 =item B<fdiv>(out INT, in INT, in INT)
 276
 277 =item B<fdiv>(out NUM, in NUM, in NUM)
 278
 279 =item B<fdiv>(invar PMC, invar PMC, invar PMC)
 280
 281 =item B<fdiv>(invar PMC, invar PMC, in INT)
 282
 283 =item B<fdiv>(invar PMC, invar PMC, in NUM)
 284
 285 Set $1 to the quotient of $2 divided by $3. The result is the floor()
 286 of the division i.e. the next whole integer towards -inf.
 287 If the denominator is zero, a 'Divide by zero' exception is thrown.
 288
 289 =cut
 290
 291 inline op fdiv(inout INT, in INT) :base_core {
 292     INTVAL   den = $2;
 293     FLOATVAL f;
 294
 295     if (den == 0) {
 296         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
 297             EXCEPTION_DIV_BY_ZERO,
 298             "Divide by zero");
 299         goto ADDRESS(handler);
 300     }
 301
 302     f  = floor(((FLOATVAL)$1) / den);
 303     $1 = (INTVAL)f;
 304 }
 305
 306 inline op fdiv(inout NUM, in NUM) :base_core {
 307     FLOATVAL den = $2;
 308     if (FLOAT_IS_ZERO(den)) {
 309         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
 310             EXCEPTION_DIV_BY_ZERO,
 311             "Divide by zero");
 312         goto ADDRESS(handler);
 313     }
 314     $1 = floor($1 / den);
 315 }
 316
 317 inline op fdiv(invar PMC, invar PMC) :base_core {
 318     VTABLE_i_floor_divide(interp, $1, $2);
 319 }
 320
 321 inline op fdiv(invar PMC, in INT) :base_core {
 322     VTABLE_i_floor_divide_int(interp, $1, $2);
 323 }
 324
 325 inline op fdiv(invar PMC, in NUM) :base_core {
 326     VTABLE_i_floor_divide_float(interp, $1, $2);
 327 }
 328
 329 inline op fdiv(out INT, in INT, in INT) :base_core {
 330     INTVAL   den = $3;
 331     FLOATVAL f;
 332
 333     if (den == 0) {
 334         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
 335             EXCEPTION_DIV_BY_ZERO,
 336             "Divide by zero");
 337         goto ADDRESS(handler);
 338     }
 339
 340     f  = floor((FLOATVAL)$2 / den);
 341     $1 = (INTVAL)f;
 342 }
 343
 344 inline op fdiv(out NUM, in NUM, in NUM) :base_core {
 345     FLOATVAL den = $3;
 346     if (FLOAT_IS_ZERO(den)) {
 347         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
 348             EXCEPTION_DIV_BY_ZERO,
 349             "Divide by zero");
 350         goto ADDRESS(handler);
 351     }
 352     $1 = floor($2 / den);
 353 }
 354
 355 inline op fdiv(invar PMC, invar PMC, invar PMC) :base_core {
 356     $1 = VTABLE_floor_divide(interp, $2, $3, $1);
 357 }
 358
 359 inline op fdiv(invar PMC, invar PMC, in INT) :base_core {
 360     $1 = VTABLE_floor_divide_int(interp, $2, $3, $1);
 361 }
 362
 363 inline op fdiv(invar PMC, invar PMC, in NUM) :base_core {
 364     $1 = VTABLE_floor_divide_float(interp, $2, $3, $1);
 365 }
 366
 367 ########################################
 368
 369 =item B<ceil>(inout NUM)
 370
 371 Set $1 to the smallest integral value greater than or equal to $1.
 372
 373 =item B<ceil>(out INT, in NUM)
 374
 375 =item B<ceil>(out NUM, in NUM)
 376
 377 Set $1 to the smallest integral value greater than or equal to $2.
 378
 379 =cut
 380
 381 inline op ceil(inout NUM) :base_core {
 382     $1 = ceil($1);
 383 }
 384
 385 inline op ceil(out INT, in NUM) :base_core {
 386     FLOATVAL f = ceil($2);
 387     $1         = (INTVAL)f;
 388 }
 389
 390 inline op ceil(out NUM, in NUM) :base_core {
 391     $1 = ceil($2);
 392 }
 393
 394 ########################################
 395
 396 =item B<floor>(inout NUM)
 397
 398 Set $1 to the largest integral value less than or equal to $1.
 399
 400 =item B<floor>(out INT, in NUM)
 401
 402 =item B<floor>(out NUM, in NUM)
 403
 404 Set $1 to the largest integral value less than or equal to $2.
 405
 406 =cut
 407
 408 inline op floor(inout NUM) :base_core {
 409     $1 = floor($1);
 410 }
 411
 412 inline op floor(out INT, in NUM) :base_core {
 413     FLOATVAL f = floor($2);
 414     $1         = (INTVAL)f;
 415 }
 416
 417 inline op floor(out NUM, in NUM) :base_core {
 418     $1 = floor($2);
 419 }
 420
 421 ########################################
 422
 423 =item B<inc>(inout INT)
 424
 425 =item B<inc>(inout NUM)
 426
 427 =item B<inc>(invar PMC)
 428
 429 Increase $1 by one.
 430
 431 =cut
 432
 433 inline op inc(inout INT) :base_core {
 434     $1++;
 435 }
 436
 437 inline op inc(inout NUM) :base_core {
 438     $1++;
 439 }
 440
 441 inline op inc(invar PMC) :base_core {
 442     VTABLE_increment(interp, $1);
 443 }
 444
 445
 446 ########################################
 447
 448 =item B<mod>(out INT, in INT, in INT)
 449
 450 =item B<mod>(out NUM, in NUM, in NUM)
 451
 452 =item B<mod>(invar PMC, invar PMC, invar PMC)
 453
 454 =item B<mod>(invar PMC, invar PMC, in INT)
 455
 456 =item B<mod>(invar PMC, invar PMC, in NUM)
 457
 458 Sets $1 to the modulus of $2 and $3.
 459
 460 =item B<mod>(inout INT, in INT)
 461
 462 =item B<mod>(inout NUM, in NUM)
 463
 464 =item B<mod>(invar PMC, invar PMC)
 465
 466 =item B<mod>(invar PMC, in INT)
 467
 468 =item B<mod>(invar PMC, in NUM)
 469
 470 Sets $1 to the modulus of $1 and $2.
 471
 472
 473 NOTE: This "corrected mod" algorithm is based on the C code on page 70
 474 of [1]. Assuming correct behavior of the built-in mod operator (%) with
 475 positive arguments, this algorithm implements a mathematically convenient
 476 version of mod, defined thus:
 477
 478   x mod y = x - y * floor(x / y)
 479
 480 For more information on this definition of mod, see section 3.4 of [2],
 481 pages 81-85.
 482
 483 References:
 484
 485   [1] Donald E. Knuth, *MMIXware: A RISC Computer for the Third
 486       Millennium* Springer, 1999.
 487
 488   [2] Ronald L. Graham, Donald E. Knuth and Oren Patashnik, *Concrete
 489       Mathematics*, Second Edition. Addison-Wesley, 1994.
 490
 491 =cut
 492
 493 op mod(inout INT, in INT) :base_core {
 494     $1 = intval_mod($1, $2);
 495 }
 496
 497 op mod(inout NUM, in NUM) :base_core {
 498     $1 = floatval_mod($1, $2);
 499 }
 500
 501 inline op mod(invar PMC, invar PMC) :base_core {
 502     VTABLE_i_modulus(interp, $1, $2);
 503 }
 504
 505 inline op mod(invar PMC, in INT) :base_core {
 506     VTABLE_i_modulus_int(interp, $1, $2);
 507 }
 508
 509 inline op mod(invar PMC, in NUM) :base_core {
 510     VTABLE_i_modulus_float(interp, $1, $2);
 511 }
 512
 513 op mod(out INT, in INT, in INT) :base_core {
 514     $1 = intval_mod($2, $3);
 515 }
 516
 517 op mod(out NUM, in NUM, in NUM) :base_core {
 518     $1 = floatval_mod($2, $3);
 519 }
 520
 521 inline op mod(invar PMC, invar PMC, invar PMC) :base_core {
 522     $1 = VTABLE_modulus(interp, $2, $3, $1);
 523 }
 524
 525 inline op mod(invar PMC, invar PMC, in INT) :base_core {
 526     $1 = VTABLE_modulus_int(interp, $2, $3, $1);
 527 }
 528
 529 inline op mod(invar PMC, invar PMC, in NUM) :base_core {
 530     $1 = VTABLE_modulus_float(interp, $2, $3, $1);
 531 }
 532
 533 ########################################
 534
 535 =item B<mul>(inout INT, in INT)
 536
 537 =item B<mul>(inout NUM, in NUM)
 538
 539 =item B<mul>(invar PMC, invar PMC)
 540
 541 =item B<mul>(invar PMC, in INT)
 542
 543 =item B<mul>(invar PMC, in NUM)
 544
 545 Set $1 to the product of $1 and $2.
 546
 547 =item B<mul>(out INT, in INT, in INT)
 548
 549 =item B<mul>(out NUM, in NUM, in NUM)
 550
 551 =item B<mul>(invar PMC, invar PMC, invar PMC)
 552
 553 =item B<mul>(invar PMC, invar PMC, in INT)
 554
 555 =item B<mul>(invar PMC, invar PMC, in NUM)
 556
 557 Set $1 to the product of $2 and $3.
 558
 559 =cut
 560
 561 inline op mul(inout INT, in INT) :base_core {
 562     $1 *= $2;
 563 }
 564
 565 inline op mul(inout NUM, in NUM) :base_core {
 566     $1 *= $2;
 567 }
 568
 569 inline op mul(invar PMC, invar PMC) :base_core {
 570     VTABLE_i_multiply(interp, $1, $2);
 571 }
 572
 573 inline op mul(invar PMC, in INT) :base_core {
 574     VTABLE_i_multiply_int(interp, $1, $2);
 575 }
 576
 577 inline op mul(invar PMC, in NUM) :base_core {
 578     VTABLE_i_multiply_float(interp, $1, $2);
 579 }
 580
 581 inline op mul(out INT, in INT, in INT) :base_core {
 582     $1 = $2 * $3;
 583 }
 584
 585 inline op mul(out NUM, in NUM, in NUM) :base_core {
 586     $1 = $2 * $3;
 587 }
 588
 589 inline op mul(invar PMC, invar PMC, invar PMC) :base_core {
 590     $1 = VTABLE_multiply(interp, $2, $3, $1);
 591 }
 592
 593 inline op mul(invar PMC, invar PMC, in INT) :base_core {
 594     $1 = VTABLE_multiply_int(interp, $2, $3, $1);
 595 }
 596
 597 inline op mul(invar PMC, invar PMC, in NUM) :base_core {
 598     $1 = VTABLE_multiply_float(interp, $2, $3, $1);
 599 }
 600
 601 ########################################
 602
 603 =item B<neg>(inout INT)
 604
 605 =item B<neg>(inout NUM)
 606
 607 =item B<neg>(invar PMC)
 608
 609 Set $1 to its negative.
 610
 611 =item B<neg>(out INT, in INT)
 612
 613 =item B<neg>(out NUM, in NUM)
 614
 615 =item B<neg>(out PMC, invar PMC)
 616
 617 Set $1 to the negative of $2.
 618
 619 =cut
 620
 621 inline op neg(inout INT) :base_core {
 622     $1 = - $1;
 623 }
 624
 625 inline op neg(inout NUM) :base_core {
 626     $1 = - $1;
 627 }
 628
 629 inline op neg(invar PMC) :base_core {
 630     VTABLE_i_neg(interp, $1);
 631 }
 632
 633 inline op neg(out INT, in INT) :base_core {
 634     $1 = - $2;
 635 }
 636
 637 inline op neg(out NUM, in NUM) :base_core {
 638     $1 = - $2;
 639 }
 640
 641 inline op neg(out PMC, invar PMC) :base_core {
 642     $1 = VTABLE_neg(interp, $2, $1);
 643 }
 644
 645 ########################################
 646
 647 =item B<sub>(inout INT, in INT)
 648
 649 =item B<sub>(inout NUM, in NUM)
 650
 651 =item B<sub>(invar PMC, invar PMC)
 652
 653 =item B<sub>(invar PMC, in INT)
 654
 655 =item B<sub>(invar PMC, in NUM)
 656
 657 Decrease $1 by the amount in $2.
 658
 659 =item B<sub>(out INT, in INT, in INT)
 660
 661 =item B<sub>(out NUM, in NUM, in NUM)
 662
 663 =item B<sub>(invar PMC, invar PMC, invar PMC)
 664
 665 =item B<sub>(invar PMC, invar PMC, in INT)
 666
 667 =item B<sub>(invar PMC, invar PMC, in NUM)
 668
 669 Set $1 to $2 minus $3.
 670
 671 =cut
 672
 673 inline op sub(inout INT, in INT) :base_core {
 674     $1 -= $2;
 675 }
 676
 677 inline op sub(inout NUM, in NUM) :base_core {
 678     $1 -= $2;
 679 }
 680
 681 inline op sub(invar PMC, invar PMC) :base_core {
 682     VTABLE_i_subtract(interp, $1, $2);
 683 }
 684
 685 inline op sub(invar PMC, in INT) :base_core {
 686     VTABLE_i_subtract_int(interp, $1, $2);
 687 }
 688
 689 inline op sub(invar PMC, in NUM) :base_core {
 690     VTABLE_i_subtract_float(interp, $1, $2);
 691 }
 692
 693 inline op sub(out INT, in INT, in INT) :base_core {
 694     $1 = $2 - $3;
 695 }
 696
 697 inline op sub(out NUM, in NUM, in NUM) :base_core {
 698     $1 = $2 - $3;
 699 }
 700
 701 inline op sub(invar PMC, invar PMC, invar PMC) :base_core {
 702     $1 = VTABLE_subtract(interp, $2, $3, $1);
 703 }
 704
 705 inline op sub(invar PMC, invar PMC, in INT) :base_core {
 706     $1 = VTABLE_subtract_int(interp, $2, $3, $1);
 707 }
 708
 709 inline op sub(invar PMC, invar PMC, in NUM) :base_core {
 710     $1 = VTABLE_subtract_float(interp, $2, $3, $1);
 711 }
 712
 713 ########################################
 714
 715 =item B<sqrt>(out NUM, in NUM)
 716
 717 Set $1 to the square root of $2.
 718
 719 =cut
 720
 721 inline op sqrt(out NUM, in NUM) :base_core {
 722     $1 = sqrt((FLOATVAL)$2);
 723 }
 724
 725 =back
 726
 727 =cut
 728
 729 ###############################################################################
 730
 731 =head1 COPYRIGHT
 732
 733 Copyright (C) 2001-2009, Parrot Foundation.
 734
 735 =head1 LICENSE
 736
 737 This program is free software. It is subject to the same license
 738 as the Parrot interpreter itself.
 739
 740 =cut
 741
 742 /*
 743  * Local variables:
 744  *   c-file-style: "parrot"
 745  * End:
 746  * vim: expandtab shiftwidth=4:
 747  */