Oh but it is. From perlop
Binary "%" computes the modulus of two numbers. Given integer operands $a and $b :

One minute!;)

Ido,
Actually - it could be anywhere from 1 to 119 seconds but I think it was closer to about 10.

Cheers - L~R

perldoc perlop says:

Binary "%" computes the modulus of two numbers. Given integer operands "$a" and "$b": If "$b" is positive, then "$a % $b" is "$a" minus the largest multiple of "$b" that is not greater than "$a". If "$b" is negative, then "$a % $b" is "$a" minus the smallest multiple of "$b" that is not less than "$a" (i.e. the result will be less than or equal to zero). Note than when "use integer" is in scope, "%" gives you direct access to the modulus operator as implemented by your C compiler. This operator is not as well defined for negative operands, but it will execute faster.

Note the part about "integer operands". I suspect that the arguments got truncated to integers, leading to the cases "4 % 0" and "4 % 2". One can readily imply that Perl does not define % for non-integer arguments. If you need that, you need to write your own implementation.

# get the fractional portion of a number
sub frac { $_[0]-int($_[0]) }

# find the remainder in a real division
sub rem { $_[1]*frac($_[0]/$_[1]) }
[download]

This becomes a battle of semantics. Mostly one only sees modulo arithmetic defined for integers, where the modulus needs to be a positive integer. But there are definely analogous systems that deal with fractions, and i suppose that they can be extended to reals, although taking the modulus of something (mod pi) seems pretty weird to me.

But as a mathematician, as long as the system definition is consistent, there shouldnt be any problem.

I do recall in an old (1950's) number theory book that got from a clearance rack (old crap free for the taking) from my universities math department (which i still posess), it is left as an exercise to extend modular arithmetic to include fractions. Ouch!, but such things are feasible.

I should read the link you cited, but am way too busy right now.

... although taking the modulus of something (mod pi) seems pretty weird ...

Not only weird but for such transcendental numbers as pi or e I can imagine that the result is undefined!

CountZero

"If you have four groups working on a compiler, you'll get a 4-pass compiler." - Conway's Law

You can rewrite the modulus function as:

sub my_mod {
    my ( $a, $b ) = @_;
    my $div = $a / $b;
    return $a - int( $div ) * $b;
}

print my_mod( 4, 1.5 ), "\n";   # 1
print my_mod( 4, 0.5 ), "\n";   # 0
print my_mod( 4, 0.7 ), "\n";   # 0.5
[download]

This is for C (and BASIC) compatibility.

Are you saying it was it was designed to be compatible with C and BASIC, or are you simply pointing out that the design is compatible with C and BASIC? (and Turbo Pascal and MODULA-II and Java).

I think/hope he's being ironic :-).

use strict;
use warnings;

print myrem(4, 2.5);

sub myrem { return $_[0] - int ($_[0] / $_[1]) * $_[1]; };
[download]