view release on metacpan or  search on metacpan

devel/theodorus.pl  view on Meta::CPAN

  #               ...
  #               (-1)^m*Bm     (m-1)       (m-1)
  #             + --------- * (f     (n) - f     (1))
  #                  m!
  #               ...
  # B0=1
  # B1=-1/2
  my $B2 = 1/6;
  my $B3 = 0;
  my $B4 = -1/30;

  # f(x) = arctan 1/sqrt(x)
  # f'(x) = 1/(1+x^2)
  # f'2(x) = (-1 * (2 * x)) / (((x ^ 2) + 1) ^ 2)
  #        = -2x / (x^2 + 1)^2

  foreach my $x (1 .. 40) {
    my $sum = fsum($x);
    my $ifx = ifx($x) - ifx(1) - (fx($x)-fx(1))/2;
    my $t1 = $B2/2 * (dfx($x) - dfx(1));
    my $if2 = $ifx + $t1;
    printf "%.4f %.4f[%.4f] %.4f[%.4f]\n",
      $sum, $ifx, $ifx-$sum, $if2, $if2-$sum;
  }

  sub ifx {
    my ($x) = @_;
    return sqrt($x) + $x*fx($x) - atan2($x,1);
  }
  sub fx {
    my ($x) = @_;
    return atan2(1, sqrt($x));
  }
  sub dfx {
    my ($x) = @_;
    return 1/($x*$x+1);
  }
  sub ddfx {
    my ($x) = @_;
    return -2*$x/(($x*$x+1)**2);
  }

  sub fsum {
    my ($x) = @_;
    my $ret = 0;
    foreach my $i (1 .. $x-1) {
      $ret += fx($x);
    }
    return $ret;
  }

  exit 0;
}

{
  {
    package Math::Symbolic::Custom::MySimplification;
    use base 'Math::Symbolic::Custom::Simplification';

    # use Math::Symbolic::Custom::Pattern;
    # my $formula = Math::Symbolic->parse_from_string("TREE_a * (TREE_b / TREE_c)");
    # my $pattern = Math::Symbolic::Custom::Pattern->new($formula);

    use Math::Symbolic::Custom::Transformation;
    my $trafo = Math::Symbolic::Custom::Transformation::Group->new
      (',',
       'TREE_a * (TREE_b / TREE_c)' => '(TREE_a * TREE_b) / TREE_c',
       'TREE_a * (TREE_b + TREE_c)' => 'TREE_a * TREE_b + TREE_a * TREE_c',
       '(TREE_b + TREE_c) * TREE_a' => 'TREE_b * TREE_a + TREE_c * TREE_a',

       # '(TREE_a / TREE_b) / TREE_c' => 'TREE_a / (TREE_b * TREE_c)',

       '(TREE_a / TREE_b) / (TREE_c / TREE_d)'
       => '(TREE_a * TREE_d) / (TREE_b * TREE_c)',

       '1 - TREE_a / TREE_b' => '(TREE_b - TREE_a) / TREE_b',

       'TREE_a / TREE_b + TREE_c' => '(TREE_a + TREE_b * TREE_c) / TREE_b',

       '(TREE_a / TREE_b) * TREE_c' => '(TREE_a * TREE_c) / TREE_b',

       'TREE_a - (TREE_b + TREE_c)' => 'TREE_a - TREE_b - TREE_c',
       '(TREE_a - TREE_b) - TREE_c' => 'TREE_a - TREE_b - TREE_c',

      );

    sub simplify {
      my $tree = shift;
      ### simplify(): "$tree"
      ### traf: ($trafo->apply_recursive($tree)//'').''
      return $trafo->apply_recursive($tree) || $tree;

      # if (my $m = $pattern->match($tree)) {
      #   $m = $m->{'trees'};
      #   ### trees: $m
      #   ### return: ($m->{'a'} * $m->{'b'}) / $m->{'c'}
      #   return ($m->{'a'} * $m->{'b'}) / $m->{'c'};
      # } else {
      #   ### no match
      #   return $tree;
      # }
    }
    __PACKAGE__->register();
  }

  require Math::Symbolic;
  require Math::Symbolic::Derivative;
  {
    my $t = Math::Symbolic->parse_from_string('1/(x^2+1)');
    $t = Math::Symbolic::Derivative::total_derivative($t, 'x');
    
    $t = $t->simplify;
    print "$t\n";
    exit 0;
  }

  {
    my $a = Math::Symbolic->parse_from_string(
                                              '(x+y)/(1-x*y)'
                                             );
    my $z = Math::Symbolic->parse_from_string(
                                              'z'