view release on metacpan or  search on metacpan

devel/dragon.pl  view on Meta::CPAN

        $p = $q;
      }
    }
  }
  foreach my $a (-15 .. 15) {
    foreach my $b (-15 .. 15) {
      foreach my $c (1 .. 15) {
        next if $a == 0 && $b == 0 && $c == 0;
        next if abs($a) == 1 && $b == 0 && $c == 0;
        my $d = Math::Polynomial->new($a,$b,$c);
        my ($q,$r) = $p->divmod($d);
        if ($r == 0 && poly_is_integer($q)) {
          print "/ $d = $q  rem $r\n";
          $p = $q;
        }
      }
    }
  }
  print "final $p\n";
  exit 0;

  sub poly_is_integer {
    my ($p) = @_;
    foreach my $coeff ($p->coefficients) {
      unless ($coeff == int($coeff)) {
        return 0;
      }
    }
    return 1;
  }
}

{
  my $path = Math::PlanePath::DragonCurve->new;
  sub level_to_join_area {
    my ($level) = @_;
    {
      if ($level == 0) { return 0; }
      if ($level == 1) { return 0; }
      if ($level == 2) { return 0; }
      if ($level == 3) { return 1; }
      my $j0 =  0;
      my $j1 =  0;
      my $j2 =  0;
      my $j3 =  1;
      foreach (4 .. $level) {
        ($j3,$j2,$j1,$j0) = (2*$j3 - $j2 + 2*$j1 - 2*$j0,  $j3, $j2, $j1);
      }
      return $j3;
    }

    return ($path->_UNDOCUMENTED_level_to_right_line_boundary($level+1)
            - $path->_UNDOCUMENTED_level_to_left_line_boundary($level+1)) / 4;

    return ($path->_UNDOCUMENTED_level_to_line_boundary($level) / 2
            - $path->_UNDOCUMENTED_level_to_line_boundary($level+1) / 4);

    return ($path->_UNDOCUMENTED_level_to_enclosed_area($level+1)
            - 2*$path->_UNDOCUMENTED_level_to_enclosed_area($level));
  }
  sub level_to_join_points_by_formula {
    my ($level) = @_;
    {
      if ($level == 0) { return 1; }
      if ($level == 1) { return 1; }
      if ($level == 2) { return 1; }
      if ($level == 3) { return 2; }
      my $j0 =  1;
      my $j1 =  1;
      my $j2 =  1;
      my $j3 =  2;
      foreach (4 .. $level) {
        ($j3,$j2,$j1,$j0) = (2*$j3 - $j2 + 2*$j1 - 2*$j0,  $j3, $j2, $j1);
      }
      return $j3;
    }
    return level_to_join_area($level) + 1;
  }

  my @values;
  my $prev_visited = 0;
  foreach my $k (0 .. 11) {
    my $n_end = 2**$k;
    # my %seen;
    # foreach my $n (0 .. $n_end) {
    #   my ($x,$y) = $path->n_to_xy($n);
    #   $seen{"$x,$y"}++;
    # }
    my $u = $path->_UNDOCUMENTED_level_to_u_left_line_boundary($k);
    my $ru = $path->_UNDOCUMENTED_level_to_u_right_line_boundary($k);
    my $bu = $path->_UNDOCUMENTED_level_to_u_line_boundary($k);
    my $ja = level_to_join_area($k);
    my $join_points = path_level_to_join_points($path,$k);
    my $join_area = $join_points - 1;
    my $j = level_to_join_points_by_formula($k);
    my $da = level_to_denclosed($k);
    my $area = $path->_UNDOCUMENTED_level_to_enclosed_area($k);
    my $area_next = $path->_UNDOCUMENTED_level_to_enclosed_area($k+1);
    my $darea = $area_next - $area;
    my $v = $path->_UNDOCUMENTED_level_to_visited($k);
    my $visited = $v; # MyOEIS::path_n_to_visited($path,$n_end);
    my $dvisited = $visited - $prev_visited;

    my $singles = 0 && MyOEIS::path_n_to_singles($path, $n_end-1);
    my $doubles = 0 && MyOEIS::path_n_to_doubles($path, $n_end-1);
    print "$k  join=$join_points,$j da=$area_next-$area=$da $visited $v\n";

    push @values, ($dvisited-1)/2;
    $prev_visited = $visited;

    # dvisited       = 2,1,2,4,7,13,25,47,89,171,329,635,1233,2403,4697
    # dvisited-1     = 1,0,1,3,6,12,24,46,88,170,328,634,1232,2402,4696
    # (dvisited-1)/2 = 0.5,0,0.5,1.5, 3,6,12,23,44,85,164,317
    # (dvisited-1)/2 differs from A001630 tetranacci at k=11
  }
  print join(',',@values),"\n";
  shift @values;
  shift @values;
  shift @values;
  shift @values;
  shift @values;
  Math::OEIS::Grep->search(array => \@values);
  exit 0;

  sub level_to_denclosed {
    my ($k) = @_;
    return ($path->_UNDOCUMENTED_level_to_enclosed_area($k+1)
            - $path->_UNDOCUMENTED_level_to_enclosed_area($k));
  }

  sub path_level_to_join_points {
    my ($path, $k) = @_;
    my $n_level = 2**$k;
    my $join;
    foreach my $n ($n_level .. 2*$n_level) {
      foreach my $n ($path->xy_to_n_list($path->n_to_xy($n))) {
        $join += ($n <= $n_level);
      }
    }
    return $join;
  }
}

{
  # singles positions
  my $path = Math::PlanePath::DragonCurve->new;

  foreach my $k (0 .. 6) {
    my $n_end = 2**$k;
    foreach my $n (0 .. $n_end) {
      my @n_list = $path->n_to_n_list($n);
      if (@n_list == 1
          || (@n_list == 2 && $n_list[1] > $n_end)) {
        # my $n = $n ^ ($n >> 1);
        my $str = sprintf "%8b", $n;

devel/dragon.pl  view on Meta::CPAN

}





{
  # diagonal

  #
  #                       |---8
  #                       |
  #                       v
  #                       6<--
  #                           |
  #                           |
  #                   0   |---4
  #                   |   |
  #                   |   v
  #                   |-->2
  #
  # new xmax = ymax or -ymin or 2L-xmin
  # new xmin = ymin
  # new ymax = 2L-ymin
  # new ymin = -xmax or -ymax            same

  my $xmax = 1;
  my $xmin = 0;
  my $ymax = 1;
  my $ymin = 0;
  my $len = 1;
  my $exp = 8;
  for (1 .. $exp) {
    printf "%2d %-18s %-18s %-18s %-18s\n",
      $_, to_bin($xmin),to_bin($xmax), to_bin($ymin),to_bin($ymax);
    ($xmax,
     $xmin,
     $ymax,
     $ymin)
      =
        (max($ymax, -$ymin, 2*$len-$xmin),
         min($ymin),
         2*$len-$ymin,
         min(-$xmax,-$ymax));
    ### assert: $xmin <= 0
    ### assert: $ymin <= 0
    ### assert: $xmax >= 0
    ### assert: $ymax >= 0
    $len *= 2;
  }
  print 3*$xmin/$len+.001," / 3\n";
  print 6*$xmax/$len+.001," / 6\n";
  print 3*$ymin/$len+.001," / 3\n";
  print 3*$ymax/$len+.001," / 3\n";
}




{
  # A073089 midpoint vertical/horizontal formula

  require Math::NumSeq::OEIS::File;
  my $A073089 = Math::NumSeq::OEIS::File->new (anum => 'A073089');

  my $A014577 = Math::NumSeq::OEIS::File->new (anum => 'A014577'); # 0=left n=0
  my $A014707 = Math::NumSeq::OEIS::File->new (anum => 'A014707'); # 1=left
  my $A038189 = Math::NumSeq::OEIS::File->new (anum => 'A038189');
  my $A082410 = Math::NumSeq::OEIS::File->new (anum => 'A082410');

  my $A000035 = Math::NumSeq::OEIS::File->new (anum => 'A000035'); # n mod 2

  my $count = 0;
  foreach my $n (0 .. 1000) {
    my $got = $A073089->ith($n) // next;

    # works except for n=1
    # my $turn = $A014707->ith($n-2) // next;
    # my $flip = $A000035->ith($n-2) // next;
    # my $calc = $turn ^ $flip;

    # works
    # my $turn = $A014577->ith($n-2) // next;
    # my $flip = $A000035->ith($n-2) // next;
    # my $calc = $turn ^ $flip ^ 1;

    # so A073089(n) = A082410(n) xor A000035(n) xor 1
    my $turn = $A082410->ith($n) // next;
    my $flip = $A000035->ith($n) // next;
    my $calc = $turn ^ $flip ^ 1;

    if ($got != $calc) {
      print "wrong $n  got=$got calc=$calc\n";
    }
    $count++;
  }
  print "count $count\n";
  exit 0;
}

{
  # doublings
  require Math::PlanePath::DragonCurve;
  my $path = Math::PlanePath::DragonCurve->new;
  my %seen;
  for (my $n = 0; $n < 2000; $n++) {
    my ($x,$y) = $path->n_to_xy($n);
    my $key = "$x,$y";
    push @{$seen{$key}}, $n;
    if (@{$seen{$key}} == 2) {
      my @v2;
      my $aref = delete $seen{$key};
      my $sum = 0;
      foreach my $v (@$aref) {
        $sum += $v;
        my $v2 = Math::BaseCnv::cnv($v,10,2);
        push @v2, $v2;
        printf "%4s %12s\n", $v, $v2;
      }
      printf "%4s %12b  sum\n", $sum, $sum;