root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

#!/usr/bin/env perl6

use lib <../lib>;

use Number::More :ALL;

# a test set of numbers and bases
my $nums    = 100; # nums to choose
my $ndigits = 5;   # num digits per number

my @b = 11..62; # set of allowable bases
my @p = @b; # need an array to pick from since @b is used in a loop 

my @dd = <0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 7 8 9>;
for 1..$nums -> $i {
    # pick digits at random
    #my @d = pick $ndigits, @dec2digit;
    my @d = @dd.pick: $ndigits;
    my $num-i = join '', @d;
    say "== number $i: $num-i";

    my $base-i = 10;

    # pick each valid output base
    for @b -> $base-o {
       say "  base-i: $base-i; base-o: $base-o";

       my $res;
       $res = _from-dec-to-b37-b62($num-i, $base-o);

       say "  output: $res";
    }
}

sub _to-dec-from-b37-b62($num,
			 #UInt $bi where { 36 < $bi < 63 }
			 UInt $bi
			 --> Cool
			) is export(:_to-dec-from-b37-b62) {

    # see simple algorithm for base to dec:
    #`{

Let's say you have a number

  10121 in base 3

and you want to know what it is in base 10.  Well, in base three the
place values [from the highest] are

   4   3  2  1  0 <= digit place (position)
  81, 27, 9, 3, 1 <= value: digit x base ** place

so we have 1 x 81 + 0 x 27 + 1 x 9 + 2 x 3 + 1 x 1

  81 + 0 + 9 + 6 + 1 = 97

that is how it works.  You just take the number, figure out the place
values, and then add them together to get the answer.  Now, let's do
one the other way.

45 in base ten (that is the normal one.) Let's convert it to base
five.

Well, in base five the place values will be 125, 25, 5, 1

We won't have any 125's but we will have one 25. Then we will have 20
left.  That is four 5's, so in base five our number will be 140.

Hope that makes sense.  If you don't see a formula, try to work out a
bunch more examples and they should get easier.

-Doctor Ethan,  The Math Forum

    }

    # reverse the digits of the input number
    my @num'r = $num.comb.reverse;
    my $place = $num.chars;

    my $dec = 0;
    for @num'r -> $digit {
	--$place; # first place is num chars - 1
	# need to convert the digit to dec first
	my $digit-val = %digit2dec{$digit};
	my $val = $digit-val * $bi ** $place;
	$dec += $val;
    }
    return $dec;
}

#sub _from-dec-to-b37-b62(UInt $x'dec ,
sub _from-dec-to-b37-b62($x'dec ,
			 #UInt $base-o where { 36 < $base-o < 63 }
			 UInt $base-o
		         --> Str) is export(:_from-dec-to-b37-b62) {
    # see Wolfram's solution (article Base)

    # need ln_b x = ln x / ln b
    my $log_b'x = log $x'dec / log $base-o; # note p6 routine 'log' is math function 
                                            # 'ln' if no optional base arg

    # get place index of first digit
    my $n = floor $log_b'x;

    # now the algorithm
    # we need @r below to be a fixed array of size $n + 2
    my @r[$n + 2];
    my @a[$n + 1];

    @r[$n] = $x'dec;

    # work through the $x'dec.chars places (????)
    # for now just handle integers (later, real, i.e., digits after a fraction point)
    #for $n..0 -> $i {
    for $n..0 -> $i { # <= Wolfram text is misleading here
	my $b'i  = $base-o ** $i;
	@a[$i]   = floor (@r[$i] / $b'i);

        say "  i = $i; a = '@a[$i]'; r = '@r[$i]'"; 

        # calc r for next iteration
	@r[$i-1] = @r[$i] - @a[$i] * $b'i;
    }

    

# @a contains the index of the digits of the number in the new base
my $x'b = '';
for @a -> $di {
    my $digit = @dec2digit[$di];
    $x'b ~= $digit;
}



    return "dummy return";
}

sub rebase-b37-b62($x, $bi, $bo) {
    # error checks (see sub rebase)
    # is x valid member of base bi?
    # are bi and bo valid bases?
    # are bi or bo > 36?
    my $err = 0;

}


base2dec-simple

#!/usr/bin/env raku

use Text::More :strip-comment;

class eg {
    has @!w;   # used for construction
    has $.dec;
    has $.bin;
    has $.hex;
    has $.oct;
    has $.base;
    has $.num; # number in $base format

    submethod BUILD(:words(:@!w)) {
        $!dec  = @!w[0];
        $!bin  = @!w[1];
        $!hex  = @!w[2];
        $!oct  = @!w[3];
        $!base = @!w[4];
        $!num  = @!w[5];
    }
}



read a formatted file of pipe-separated lines consisting of:


decimal, binary, hexadecimal, octal, base num, number


goal is to cover all bases 2..62 excluding 2, 8, 10, and 16


for data in each line, check conversions from and to each



my $debug = 0;
$debug = 1 if @*ARGS.elems;

my $ifil = 'base-conversions.dat';
my $ofil = '060-auto-transform-checks.t';

my @egs;

for $ifil.IO.lines -> $line is copy {
   $line = strip-comment $line;
   # ignore empty lines
   next if $line !~~ /\S/;
   $line ~~ s:g/'|'//;

   # take care of the cases of empty pipe lines awaiting data
   next if $line !~~ /\S/;

   # transliterate the line [VERY IMPORTANT!!]
   $line .= trans( 'a'..'z' => 'A'..'Z', 'A'..'Z' => 'a'..'z' );

   my @w = $line.words;

   if $debug {
       print "$_; " for @w;
       say '';
   }

   my $e = eg.new(:words(@w));
   say $e.dec if $debug;
   @egs.append: $e;
}

if $debug {
    say $_.dec for @egs;
}

# we have the source data, now write the test file...
my $fh = open $ofil, :w;

# header info
$fh.print: q:to/HERE/;
use Test;

use Number::More :ALL;

plan 456;

my $debug = 0;

my $suffix = True;
HERE

# step through the data set
my $tnum = 0;
for @egs -> $e {

    # calc and check base conversions
    my $num-dec = $e.dec;
    my $num-bin = $e.bin;
    my $num-oct = $e.oct;
    my $num-hex = $e.hex;
    my $base    = $e.base;
    my $num-num = $e.num;

    $fh.print: qq:to/HERE/;

    is rebase($num-dec, 10, $base), "$num-num", "base $base; test {++$tnum}";
    is rebase("$num-bin", 2, $base), "$num-num", "base $base; test {++$tnum}";
    is rebase("$num-oct", 8, $base), "$num-num", "base $base; test {++$tnum}";
    is rebase("$num-hex", 16, $base), "$num-num", "base $base; test {++$tnum}";

    # add the suffix
    is rebase($num-dec, 10, $base, :\$suffix), "{$num-num}_base-$base", "base $base; test {++$tnum}";
    is rebase("$num-bin", 2, $base, :\$suffix), "{$num-num}_base-$base", "base $base; test {++$tnum}";
    is rebase("$num-oct", 8, $base, :\$suffix), "{$num-num}_base-$base", "base $base; test {++$tnum}";
    is rebase("$num-hex", 16, $base, :\$suffix), "{$num-num}_base-$base", "base $base; test {++$tnum}";
    HERE
}

say "Normal end.";
say "See output file '$ofil'.";


convert-examples

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

Number::More v0.2.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation