Math::Base - arithmetics with baseX integers (updated)

Another "Silly use for Perl" entry.

Anonymous Monk asked for a method for incrementing mixed letters and numbers recently, which particular need is satisfied with Math::Base36. Can we do better? I guess, yes.

use 5.10.0;
use Math::Base;

my $begin = Math::Base->new(36, 1009, 1); # base, number, is_encoded
my $end   = Math::Base->new(36, 1020, 1);
my $c     = Math::Base->new(36, 42);

say $c->encode($_) for $begin .. $end;

# 1009
# 100A
# 100B
# 100C
# ...
# 101X
# 101Y
# 101Z
# 1020

# also (with updated code below)
# my $x = Math::Base->new(36, 46664); # 1008 in base36
# say ++$x for 0..63; # output same as above

# Arithmetics with different encodings:

$p = Math::Base->new(8,777,1); # decimal 511
$z = Math::Base->new(36, 35);  # 'Z' as base36
say $z * $p;                   # 42735 (octal)
say $p * $z;                   # 'DST' (base36)

# Changing the string representation:

$s = Math::Base->new(16,18);
say $s;                        # 12
$s->rebase(18);
say $s;                        # 10
$s += 3;                       # 13
$s->rebase(2);
say $s;                        # 10101

# Get decimal value:

$xyz = Math::Base->new(64, 'XYZabc', 1);
say $xyz->num;                 # 36013230438
[download]

Far from complete, but fun enough yet. For me, that is... ;-)

package Math::Base;
use strict; use warnings;
use overload (
    '""' => \&encode,
    '0+' => \&num,
    '-'  => \&minus,
    '+'  => \&add,
    '*'  => \&mul,
    '/'  => \&div,
);

my %hash;
my @chars     = (0..9,'A'..'Z','a'..'z',map{chr$_}32..47,58..64,91..96
+);
@hash{@chars} = 0..$#chars;

sub new {
    my ($class, $base, $value, $encoded) = @_;
    my $self = bless [$base, $value], $class;
    $self->decode if $encoded;
    $self;
}

sub rebase { $_[0]->[0] = $_[1] }
   
sub num { shift->[1] }
sub minus {
    my ($self, $other, $swap) = @_;
    my $result = $self->[1] - $other;
    $result = -$result if $swap;
    ref $result ? $result : bless [$self->[0],$result];
}
sub add {
    my ($self, $other, $swap) = @_;
    my $result = $self->[1] + $other;
    ref $result ? $result : bless [$self->[0],$result];
}
sub mul {
    my ($self, $other, $swap) = @_;
    my $result = $self->[1] * $other;
    ref $result ? $result : bless [$self->[0],$result];
}
sub div {
    my ($self, $other, $swap) = @_;
    my $result = $swap ? $other / $self->[1] : $self->[1] / $other;
    int(ref $result ? $result : bless [$self->[0],$result]);
}

sub encode {
    my $self = shift;
    my ($base,$num) = @$self;
    $num = shift if $_[0];
    my ($rem,@ret);
    while ($num) {
        push @ret, $chars[($rem = $num % $base)];
        $num -= $rem;
        $num /= $base;
    }
    return join '', reverse @ret;
}


sub decode {
    my $self = shift;
    my ($base, $str) = @$self;
    $str = shift if $_[0];
    my $num = 0;
    $num = $num * $base + $hash{$_} for $str =~ /./g;
    $self->[1] = $num;
}
1;
__END__
[download]

Update: Below is an updated version which handles negative numbers, implements missing operators and lets you define your own charset for baseX conversion, e.g. to calculate base3 with qw(a b c). Also, a method integer() is added which emulates use integer globally for all calculations, and some utility methods/functions.

Update: fixed some bugs

I'll eventually make it into a CPAN package proper.

perl -le'print map{pack c,($-++?1:13)+ord}split//,ESEL'

Comment on Math::Base - arithmetics with baseX integers (updated) Select or Download Code

Replies are listed 'Best First'.
Re: Math::Base - arithmetics with baseX integers by no_slogan (Deacon) on Aug 22, 2017 at 14:32 UTC
This is a neat idea, but `encode` spins forever when `$num` is negative and returns an empty string when it's zero. You could do this: `my $val = abs($num); do { push @ret, $chars[$val % $base]; $val = int($val / $base); } while $val; push @ret, '-' if $num < 0;` [download] But `'-'` is in the `@chars` array.	[reply] [d/l]
Re^2: Math::Base - arithmetics with baseX integers (OP updated) by shmem (Chancellor) on Aug 23, 2017 at 12:16 UTC
What I did is to mimic the behavior of sprintf and hex in `encode()`, i.e. roll over: `$num = (~abs($num))+1 if $num < 0;` [download] And the return line now reads: `return join( '', reverse @ret) \|\| 0;` [download] I've updated the op with the new version. Thanks for your hints! perl -le'print map{pack c,($-++?1:13)+ord}split//,ESEL'	[reply] [d/l] [select]
Re^3: Math::Base - arithmetics with baseX integers (OP updated) by no_slogan (Deacon) on Aug 23, 2017 at 18:08 UTC
`$num = int $num; $num = (~abs($num))+1 if $num < 0;` You can get the same effect with `$num \|= 0;` ...but... why? Why would you want two's complement behavior in other bases? Truncating at $n bits is mathematically equivalent to: `$num %= 2 $n;` That's only meaningful for base-2. You can truncate at $n base-$b digits using this: `$num %= $b $n;` So -1 becomes 999999 in base-10 or 666666 in base-7. If you want, you can pick a big number of digits that still fits in a double-precision float like this: `$num %= $base ** int(36.73/log($base));`	[reply]
Re^4: Math::Base - arithmetics with baseX integers (OP updated) by shmem (Chancellor) on Aug 23, 2017 at 19:45 UTC
Re^5: Math::Base - arithmetics with baseX integers (OP updated) by no_slogan (Deacon) on Aug 24, 2017 at 16:09 UTC
Re^4: Math::Base - arithmetics with baseX integers (OP updated) by BrowserUk (Patriarch) on Aug 24, 2017 at 00:54 UTC
Re^5: Math::Base - arithmetics with baseX integers (OP updated) by no_slogan (Deacon) on Aug 24, 2017 at 03:01 UTC
Some notes below your chosen depth have not been shown here
Re^2: Math::Base - arithmetics with baseX integers by shmem (Chancellor) on Aug 22, 2017 at 16:02 UTC
This is one of the reasons why I wrote Far from complete (besides missing pod, tests, you name it.) The perl builtins suffer from negative integer flaws also. The format `%x` of sprintf expects ~~a signed~~ an unsigned integer, but nonetheless `say $f = sprintf "%x", -15; say hex $f; __END__ fffffffffffffff1 18446744073709551601` [download] on a 64bit system. The object could get a sign flag set by the constructor which is honored by arithmetic operations, but the string representation would be ambiguous anyways if the string has a leading dash. I'm not sure what to do about that. Perhaps limiting to unsigned integers is the way to go, and `encode` should croak if the number is negative; don't know yet. update: unsigned, yes, that's the point; common typo. It is coerced into an unsigned. Thanks Anonymous Monk fo pointing out the glitch. perl -le'print map{pack c,($-++?1:13)+ord}split//,ESEL'	[reply] [d/l] [select]
Re^3: Math::Base - arithmetics with baseX integers by no_slogan (Deacon) on Aug 22, 2017 at 16:15 UTC
%x is clearly documented as taking an unsigned int in the page you link to.	[reply]
Re: Math::Base - arithmetics with baseX integers by hdb (Monsignor) on Aug 22, 2017 at 12:54 UTC
Here is my favorite example: `use Math::Base; my $one = Math::Base->new( 13, 6 ); my $two = Math::Base->new( 13, 9 ); print "$one times $two equals ", $one*$two, " base 13.\n";` [download]	[reply] [d/l]
Re^2: Math::Base - arithmetics with baseX integers by shmem (Chancellor) on Aug 22, 2017 at 14:27 UTC
Perfect for a mathematical challenge on facebook. As is 5 * 6 = 42 :-P perl -le'print map{pack c,($-++?1:13)+ord}split//,ESEL'	[reply]


Your skill will accomplish what the force of many cannot
	PerlMonks