#!/usr/bin/perl -w
# Copyright 2010, 2011, 2012, 2013 Kevin Ryde
# This file is part of Math-PlanePath.
#
# Math-PlanePath is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation; either version 3, or (at your option) any later
# version.
#
# Math-PlanePath is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# for more details.
#
# You should have received a copy of the GNU General Public License along
# with Math-PlanePath. If not, see <http://www.gnu.org/licenses/>.
use 5.004;
use strict;
use Test;
plan tests => 2;
use lib 't','xt';
use MyTestHelpers;
BEGIN { MyTestHelpers::nowarnings(); }
use MyOEIS;
use Math::BigInt try => 'GMP';
use Math::PlanePath::PythagoreanTree;
# uncomment this to run the ### lines
# use Smart::Comments '###';
#------------------------------------------------------------------------------
# A002315 NSW numbers, sum Pell(2k)-Pell(2k-1), is row P-Q
MyOEIS::compare_values
(anum => 'A002315',
max_count => 11,
func => sub {
my ($count) = @_;
my @got;
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'PQ');
for (my $depth = 0; @got < $count; $depth++) {
my $x_total = 0;
foreach my $n ($path->tree_depth_to_n($depth)
.. $path->tree_depth_to_n_end($depth)) {
my ($x,$y) = $path->n_to_xy($n);
$x_total += $x - $y;
}
push @got, $x_total;
}
return \@got;
});
# A001541 is row P+Q
MyOEIS::compare_values
(anum => 'A001541',
max_count => 11,
func => sub {
my ($count) = @_;
my @got = (1);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'PQ');
for (my $depth = 0; @got < $count; $depth++) {
my $x_total = 0;
foreach my $n ($path->tree_depth_to_n($depth)
.. $path->tree_depth_to_n_end($depth)) {
my ($x,$y) = $path->n_to_xy($n);
$x_total += $x + $y;
}
push @got, $x_total;
}
return \@got;
});
# A001653 odd Pells, is row Q total
MyOEIS::compare_values
(anum => 'A001653',
max_count => 11,
func => sub {
my ($count) = @_;
my @got;
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'PQ');
for (my $depth = 0; @got < $count; $depth++) {
my $x_total = 0;
foreach my $n ($path->tree_depth_to_n($depth)
.. $path->tree_depth_to_n_end($depth)) {
my ($x,$y) = $path->n_to_xy($n);
$x_total += $y;
}
push @got, $x_total;
}
return \@got;
});
# A001542 even Pell, is row P total
MyOEIS::compare_values
(anum => 'A001542',
max_count => 11,
func => sub {
my ($count) = @_;
my @got = (0);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'PQ');
for (my $depth = 0; @got < $count; $depth++) {
my $x_total = 0;
foreach my $n ($path->tree_depth_to_n($depth)
.. $path->tree_depth_to_n_end($depth)) {
my ($x,$y) = $path->n_to_xy($n);
$x_total += $x;
}
push @got, $x_total;
}
return \@got;
});
#------------------------------------------------------------------------------
# A000244 = 3^n is N of A repeatedly in middle of row
MyOEIS::compare_values
(anum => 'A000244',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got;
my $path = Math::PlanePath::PythagoreanTree->new;
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
push @got, ($path->tree_depth_to_n_end($depth)
+ $path->tree_depth_to_n($depth) + 1) / 2;
}
return \@got;
});
#------------------------------------------------------------------------------
# A052940 matrix T repeatedly coordinate P, binary 101111111111 = 3*2^n-1
MyOEIS::compare_values
(anum => 'A052940',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'UMT',
coordinates => 'PQ');
for (my $depth = Math::BigInt->new(1); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n_end($depth));
push @got, $x;
}
return \@got;
});
# A055010 same
MyOEIS::compare_values
(anum => 'A055010',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'UMT',
coordinates => 'PQ');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n_end($depth));
push @got, $x;
}
return \@got;
});
# A083329 same
MyOEIS::compare_values
(anum => 'A083329',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'UMT',
coordinates => 'PQ');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n_end($depth));
push @got, $x;
}
return \@got;
});
# A153893 same
MyOEIS::compare_values
(anum => 'A153893',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got;
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'UMT',
coordinates => 'PQ');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n_end($depth));
push @got, $x;
}
return \@got;
});
# A093357 matrix T repeatedly coordinate B, binary 10111..111000..000
MyOEIS::compare_values
(anum => 'A093357',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'UMT',
coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n_end($depth));
push @got, $y;
}
return \@got;
});
# A134057 matrix T repeatedly coordinate A, binomial(2^n-1,2)
# binary 111..11101000..0001
MyOEIS::compare_values
(anum => 'A134057',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0,0);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'UMT',
coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n_end($depth));
push @got, $x;
}
return \@got;
});
#------------------------------------------------------------------------------
# A106624 matrix K3 repeatedly P,Q pairs 2^k-1,2^k
MyOEIS::compare_values
(anum => 'A106624',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1,0);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'FB',
coordinates => 'PQ');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n_end($depth));
push @got, $x, $y;
}
return \@got;
});
#------------------------------------------------------------------------------
# A054881 matrix K2 repeatedly "B" coordinate
MyOEIS::compare_values
(anum => 'A054881',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1,0);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'FB',
coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $y;
}
return \@got;
});
# A015249 matrix K2 repeatedly "A" coordinate
MyOEIS::compare_values
(anum => 'A015249',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'FB',
coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $x;
}
return \@got;
});
# A084152 same
MyOEIS::compare_values
(anum => 'A084152',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0,0,1);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'FB',
coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $x;
}
return \@got;
});
# A084175 same
MyOEIS::compare_values
(anum => 'A084175',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0,1);
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'FB',
coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $x;
}
return \@got;
});
#------------------------------------------------------------------------------
# A085601 = matrix K1 repeatedly "C" coordinate, binary 10010001
MyOEIS::compare_values
(anum => 'A085601',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got;
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'FB',
coordinates => 'AC');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n($depth));
push @got, $y;
}
return \@got;
});
# A028403 = matrix K1 repeatedly "B" coordinate, binary 10010000
MyOEIS::compare_values
(anum => 'A028403',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got;
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'FB',
coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n($depth));
push @got, $y;
}
return \@got;
});
# A007582 = matrix K1 repeatedly "B/4" coordinate, binary 1001000
MyOEIS::compare_values
(anum => 'A007582',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got;
my $path = Math::PlanePath::PythagoreanTree->new (tree_type => 'FB',
coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n($depth));
push @got, $y/4;
}
return \@got;
});
#------------------------------------------------------------------------------
# A084159 matrix A repeatedly "A" coordinate, Pell oblongs
MyOEIS::compare_values
(anum => 'A084159',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $x;
}
return \@got;
});
# A046727 matrix A repeatedly "A" coordinate
MyOEIS::compare_values
(anum => 'A046727',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $x;
}
return \@got;
});
# A046729 matrix A repeatedly "B" coordinate
MyOEIS::compare_values
(anum => 'A046729',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $y;
}
return \@got;
});
# A001653 matrix A repeatedly "C" coordinate
MyOEIS::compare_values
(anum => 'A001653',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'AC');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $y;
}
return \@got;
});
# A001652 matrix A repeatedly "S" coordinate
MyOEIS::compare_values
(anum => 'A001652',
# max_count => 50,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'SM');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $x;
}
return \@got;
});
# A046090 matrix A repeatedly "M" coordinate
MyOEIS::compare_values
(anum => 'A046090',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'SM');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $y;
}
return \@got;
});
# A000129 matrix A repeatedly "P" coordinate
MyOEIS::compare_values
(anum => 'A000129',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0,1);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'PQ');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy(3 ** $depth);
push @got, $x;
}
return \@got;
});
#------------------------------------------------------------------------------
# A099776 = matrix U repeatedly "C" coordinate
MyOEIS::compare_values
(anum => 'A099776',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got;
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'AC');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n($depth));
push @got, $y;
}
return \@got;
});
# A001844 centred squares same
MyOEIS::compare_values
(anum => 'A001844',
# max_count => 100,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (1);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'AC');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n($depth));
push @got, $y;
}
return \@got;
});
# A046092 matrix U repeatedly "B" coordinate = 4*triangular
MyOEIS::compare_values
(anum => 'A046092',
# max_count => 500,
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0);
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'AB');
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n($depth));
push @got, $y;
}
return \@got;
});
#------------------------------------------------------------------------------
# A000466 matrix D repeatedly "A" coordinate = 4n^2-1
MyOEIS::compare_values
(anum => 'A000466',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (-1);
my $path = Math::PlanePath::PythagoreanTree->new;
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
my ($x,$y) = $path->n_to_xy($path->tree_depth_to_n_end($depth));
push @got, $x;
}
return \@got;
});
#------------------------------------------------------------------------------
# A058529 - all prime factors == +/-1 mod 8
# is differences mid-small legs
MyOEIS::compare_values
(anum => 'A058529',
max_count => 35,
func => sub {
my ($count) = @_;
require Math::BigInt;
my $path = Math::PlanePath::PythagoreanTree->new (coordinates => 'SM');
my %seen;
for (my $n = $path->n_start; $n < 100000; $n++) {
my ($s,$m) = $path->n_to_xy($n);
my $diff = $m - $s;
$seen{$diff} = 1;
}
my @got = sort {$a<=>$b} keys %seen;
$#got = $count-1;
return \@got;
});
#------------------------------------------------------------------------------
# A003462 = (3^n-1)/2 is tree_depth_to_n_end()
MyOEIS::compare_values
(anum => 'A003462',
func => sub {
my ($count) = @_;
require Math::BigInt;
my @got = (0);
my $path = Math::PlanePath::PythagoreanTree->new;
for (my $depth = Math::BigInt->new(0); @got < $count; $depth++) {
push @got, $path->tree_depth_to_n_end($depth);
}
return \@got;
});
#------------------------------------------------------------------------------
exit 0;