When last we left the endless Pi project, it a “simple” matter of getting FatRats to work. Which in this case, meant getting the Math::FatRat module to work. Which in turn meant getting Math::BigInt to work again. Which meant getting Zavolaj to work again. Frankly, I thought I might have a month’s worth of blog posts left in the project.

Enter Niecza. As of the latest release, it has baked-in FatRats. I was worried about it lacking lazy lists, but it turns out it has them too. I ran into four holes in its implementation of Perl 6: No floor function, no bless, no MAIN, and no sub-signatures. Luckily floor’s easy to write, MAIN is easily skipped, using the default `new`

works, and I just reverted TimToady’s sub-signature suggestion. A bit of work, and I had this, a complete and fully functional Perl 6 spigot stream for pi:

sub floor(FatRat $n) {
my $mod = $n.numerator % $n.denominator;
($n.numerator - $mod) div $n.denominator;
}
sub stream(&next, &safe, &prod, &cons, $z is copy, @x) {
my $x-list = @x.iterator.list;
gather loop {
my $y = next($z);
if safe($z, $y) {
take $y;
$z = prod($z, $y);
} else {
$z = cons($z, $x-list.shift);
}
}
}
sub convert($m, $n, @x) {
stream(-> $u { floor($u.key * $u.value * $n); },
-> $u, $y { $y == floor(($u.key + 1) * $u.value * $n); },
-> $u, $y { $u.key - $y / ($u.value * $n) => $u.value * $n; },
-> $u, $x { $x + $u.key * $m => $u.value / $m; },
0/1 => 1/1,
@x);
}
class LFT {
has $.q;
has $.r;
has $.s;
has $.t;
# method new($q, $r, $s, $t) { self.bless(*, :$q, :$r, :$s, :$t); }
method extr($x) { ($.q * $x + $.r) / ($.s * $x + $.t); }
}
sub unit() { LFT.new(q => FatRat.new(1, 1),
r => FatRat.new(0, 1),
s => FatRat.new(0, 1),
t => FatRat.new(1, 1)); }
sub comp($a, $b) {
LFT.new(q => $a.q * $b.q + $a.r * $b.s,
r => $a.q * $b.r + $a.r * $b.t,
s => $a.s * $b.q + $a.t * $b.s,
t => $a.s * $b.r + $a.t * $b.t);
}
sub pi-stream() {
stream(-> $z { floor($z.extr(3)); },
-> $z, $n { $n == floor($z.extr(4)); },
-> $z, $n { comp(LFT.new(q => 10, r => -10*$n, s => 0, t => 1), $z); },
&comp,
unit,
(1..*).map({ LFT.new(q => $_, r => 4 * $_ + 2, s => 0, t => 2 * $_ + 1) }));
}
my @pi := pi-stream;
say pi;
say @pi[0] ~ '.' ~ @pi[1..100].join('');

Certainly not as elegant as it might ideally be in the long run, but it works today, calculating 101 digits of pi in 5.7 seconds.

### Like this:

Like Loading...

*Related*

This entry was posted on June 4, 2011 at 2:54 am and is filed under Uncategorized. You can follow any responses to this entry through the RSS 2.0 feed.
You can leave a response, or trackback from your own site.

## Leave a Reply