Sat Jun 29 13:41:03 PDT 1991
REDUCE 3.4, 15-Jul-91 ...

1: 1: 
2: 2: 
3: 3: COMMENT

                 THE REDUCE INTEGRATION TEST PACKAGE

                              Edited By

                           Anthony C. Hearn
                         The RAND Corporation


This file is designed to provide a set of representative tests of the
Reduce integration package.  Not all examples go through, even when an
integral exists, since some of the arguments are outside the domain of
applicability of the current package.  However, future improvements to
the package will result in more closed-form evaluations in later
releases.  We would appreciate any additional contributions to this test
file either because they illustrate some feature (good or bad) of the
current package, or suggest domains which future versions should handle.
Any suggestions for improved organization of this test file (e.g., in a
way which corresponds more directly to the organization of a standard
integration table book such as Gradshteyn and Ryznik) are welcome.

Acknowledgments:

The examples in this file have been contributed by the following.
Any omissions to this list should be reported to the Editor.

David M. Dahm
James H. Davenport
John P. Fitch
Steven Harrington
Anthony C. Hearn
K. Siegfried Koelbig
Ernst Krupnikov
Arthur C. Norman
Herbert Stoyan
;


Comment we first set up a suitable testing functions;


fluid '(gcknt!*);



global '(faillist!* gcnumber!* inittime number!-of!-integrals
         unintlist!*);



symbolic operator time;



symbolic procedure initialize!-integral!-test;
   begin
      faillist!* := unintlist!* := nil;
      number!-of!-integrals := 0;
      gcnumber!* := gcknt!*;
      inittime := time()
   end;


INITIALIZE!-INTEGRAL!-TEST
   

symbolic procedure summarize!-integral!-test;
   begin scalar totaltime;
      totaltime := time()-inittime;
      prin2t 
   "                *****     SUMMARY OF INTEGRAL TESTS     *****";
      terpri();
      prin2 "Number of integrals tested: ";
      prin2t number!-of!-integrals;
      terpri();
      prin2 "Total time taken: ";
      prin2 totaltime;
      prin2t " ms";
      terpri();
      if gcnumber!*
        then <<prin2 "Number of garbage collections: ";
               prin2t (gcknt!* - gcnumber!*);
               terpri()>>;
      prin2 "Number of incorrect integrals: ";
            prin2t length faillist!*;
      terpri();
      prin2 "Number of unevaluated integrals: ";
      prin2t length unintlist!*;
      terpri();
      if faillist!* 
        then <<prin2t "Integrands of incorrect integrals are:";
               for each x in reverse faillist!* do mathprint car x>>;
      if unintlist!*
        then <<prin2t "Integrands of unevaluated integrals are:";
               terpri();
               for each x in reverse unintlist!* do mathprint car x>>
   end;


SUMMARIZE!-INTEGRAL!-TEST


procedure testint(a,b);
  begin scalar der,diffce,res,tt;
      tt:=time();
      symbolic (number!-of!-integrals := number!-of!-integrals + 1);
      res:=int(a,b);
%     write "time for integral:  ",time()-tt," ms";
      der := df(res,b);
      diffce := der-a;
      if diffce neq 0
        then  begin for all x let cot x=cos x/sin x,
                                  sec x=1/cos x,
                                  sin x**2=1-cos x**2,
                                  tan x=sin x/cos x,
                                  tan(x/2)=sin x/(1+cos x),
                                  tanh x=
                                     (e**(x)-e**(-x))/(e**x+e**(-x)),
                                  coth x= 1/tanh x;
                    diffce := diffce;
                    for all x clear cot x,sec x,sin x**2,tan x,tan(x/2),
                                    tanh x,coth x
              end;
        %hopefully, difference appeared non-zero due to absence of
        %above transformations;
      if diffce neq 0
        then <<write 
       "     ***** DERIVATIVE OF INTEGRAL NOT EQUAL TO INTEGRAND *****";
               symbolic(faillist!* := list(a,b,res,der) . faillist!*)>>;
               symbolic if smemq('int,res)
                    then unintlist!* := list(a,b,res) . unintlist!*;
    return res
  end;


TESTINT


symbolic initialize!-integral!-test();



% References are to Gradshteyn and Ryznik.

testint(1+x+x**2,x);


       2
 X*(2*X  + 3*X + 6)
--------------------
         6

testint(x**2*(2*x**2+x)**2,x);


  5      2
 X *(60*X  + 70*X + 21)
------------------------
          105

testint(x*(x**2+2*x+1),x);


  2     2
 X *(3*X  + 8*X + 6)
---------------------
         12

testint(1/x,x);


LOG(X)
  % 2.01 #2;
testint((x+1)**3/(x-1)**4,x);


               3                 2
(3*LOG(X - 1)*X  - 9*LOG(X - 1)*X  + 9*LOG(X - 1)*X - 3*LOG(X - 1)

       3           3      2
  - 6*X  - 2)/(3*(X  - 3*X  + 3*X - 1))

testint(1/(x*(x-1)*(x+1)**2),x);


(LOG(X - 1)*X + LOG(X - 1) + 3*LOG(X + 1)*X + 3*LOG(X + 1)

  - 4*LOG(X)*X - 4*LOG(X) + 2*X)/(4*(X + 1))

testint((a*x+b)/((x-p)*(x-q)),x);


 LOG(P - X)*A*P + LOG(P - X)*B - LOG(Q - X)*A*Q - LOG(Q - X)*B
---------------------------------------------------------------
                             P - Q

testint(1/(a*x**2+b*x+c),x);


                 2           2*A*X + B
 2*SQRT(4*A*C - B )*ATAN(------------------)
                                        2
                          SQRT(4*A*C - B )
---------------------------------------------
                          2
                 4*A*C - B

testint((a*x+b)/(1+x**2),x);


      2
 LOG(X  + 1)*A + 2*ATAN(X)*B
-----------------------------
              2

testint(1/(x**2-2*x+3),x);


                X - 1
 SQRT(2)*ATAN(---------)
               SQRT(2)
-------------------------
            2


% Rational function examples from Hardy, Pure Mathematics, p 253 et seq.

testint(1/((x-1)*(x**2+1))**2,x);


      2       3        2       2        2               2
(LOG(X  + 1)*X  - LOG(X  + 1)*X  + LOG(X  + 1)*X - LOG(X  + 1)

                  3                 2
  - 2*LOG(X - 1)*X  + 2*LOG(X - 1)*X  - 2*LOG(X - 1)*X + 2*LOG(X - 1)

             3            2                          3
  + ATAN(X)*X  - ATAN(X)*X  + ATAN(X)*X - ATAN(X) - X  - 2*X + 1)/(4

      3    2
   *(X  - X  + X - 1))

testint(x/((x-a)*(x-b)*(x-c)),x);


(LOG(A - X)*A*B - LOG(A - X)*A*C - LOG(B - X)*A*B + LOG(B - X)*B*C

                                       2      2        2      2
  + LOG(C - X)*A*C - LOG(C - X)*B*C)/(A *B - A *C - A*B  + A*C

       2        2
    + B *C - B*C )

testint(x/((x**2+a**2)*(x**2+b**2)),x);


         2    2         2    2
  - LOG(A  + X ) + LOG(B  + X )
--------------------------------
              2    2
          2*(A  - B )

testint(x**2/((x**2+a**2)*(x**2+b**2)),x);


       X             X
 ATAN(---)*A - ATAN(---)*B
       A             B
---------------------------
           2    2
          A  - B

testint(x/((x-1)*(x**2+1)),x);


         2
  - LOG(X  + 1) + 2*LOG(X - 1) + 2*ATAN(X)
-------------------------------------------
                     4

testint(x/(1+x**3),x);


                 2*X - 1          2
 2*SQRT(3)*ATAN(---------) + LOG(X  - X + 1) - 2*LOG(X + 1)
                 SQRT(3)
------------------------------------------------------------
                             6

testint(x**3/((x-1)**2*(x**3+1)),x);


           2                     2
( - 4*LOG(X  - X + 1)*X + 4*LOG(X  - X + 1) + 9*LOG(X - 1)*X

  - 9*LOG(X - 1) - LOG(X + 1)*X + LOG(X + 1) - 6*X)/(12*(X - 1))

testint(1/(1+x**4),x);


                                 2                         2
(SQRT(2)*( - LOG( - SQRT(2)*X + X  + 1) + LOG(SQRT(2)*X + X  + 1)

                     SQRT(2) - 2*X             SQRT(2) + 2*X
           - 2*ATAN(---------------) + 2*ATAN(---------------)))/8
                        SQRT(2)                   SQRT(2)

testint(x**2/(1+x**4),x);


                              2                         2
(SQRT(2)*(LOG( - SQRT(2)*X + X  + 1) - LOG(SQRT(2)*X + X  + 1)

                     SQRT(2) - 2*X             SQRT(2) + 2*X
           - 2*ATAN(---------------) + 2*ATAN(---------------)))/8
                        SQRT(2)                   SQRT(2)

testint(1/(1+x**2+x**4),x);


                 2*X - 1                     2*X + 1
(2*SQRT(3)*ATAN(---------) + 2*SQRT(3)*ATAN(---------)
                 SQRT(3)                     SQRT(3)

           2                   2
  - 3*LOG(X  - X + 1) + 3*LOG(X  + X + 1))/12


% Examples involving a+b*x.

z := a+b*x;


Z := A + B*X


testint(z**p,x);


          P
 (A + B*X) *(A + B*X)
----------------------
      B*(P + 1)

testint(x*z**p,x);


          P      2              2    2    2  2
 (A + B*X) *( - A  + A*B*P*X + B *P*X  + B *X )
------------------------------------------------
                2   2
               B *(P  + 3*P + 2)

testint(x**2*z**p,x);


          P     3      2            2  2  2      2    2    3  2  3
((A + B*X) *(2*A  - 2*A *B*P*X + A*B *P *X  + A*B *P*X  + B *P *X

                   3    3      3  3     3   3      2
              + 3*B *P*X  + 2*B *X ))/(B *(P  + 6*P  + 11*P + 6))

testint(1/z,x);


 LOG(A + B*X)
--------------
      B

testint(1/z**2,x);


      X
-------------
 A*(A + B*X)

testint(x/z,x);


  - LOG(A + B*X)*A + B*X
-------------------------
            2
           B

testint(x**2/z,x);


                 2              2  2
 2*LOG(A + B*X)*A  - 2*A*B*X + B *X
-------------------------------------
                   3
                2*B

testint(1/(x*z),x);


  - LOG(A + B*X) + LOG(X)
--------------------------
            A

testint(1/(x**2*z),x);


 LOG(A + B*X)*B*X - LOG(X)*B*X - A
-----------------------------------
                2
               A *X

testint(1/(x*z)**2,x);


                                        2  2
(2*LOG(A + B*X)*A*B*X + 2*LOG(A + B*X)*B *X  - 2*LOG(X)*A*B*X

              2  2    2      2  2    3
  - 2*LOG(X)*B *X  - A  + 2*B *X )/(A *X*(A + B*X))

testint(1/(c**2+x**2),x);


       X
 ATAN(---)
       C
-----------
     C

testint(1/(c**2-x**2),x);


 LOG( - C - X) - LOG(C - X)
----------------------------
            2*C


% More complicated rational function examples, mostly contributed
% by David M. Dahm, who also developed the code to integrate them.

testint(1/(2*x**3-1),x);


                             1/3
  2/3                     2*2   *X + 1          2/3  2    1/3
(2   *( - 2*SQRT(3)*ATAN(--------------) - LOG(2   *X  + 2   *X + 1)
                            SQRT(3)

                 1/3
        + 2*LOG(2   *X - 1)))/12

testint(1/(x**3-2),x);


                            1/3
  1/3                      2    + 2*X           2/3    1/3      2
(2   *( - 2*SQRT(3)*ATAN(--------------) - LOG(2    + 2   *X + X )
                           1/3
                          2   *SQRT(3)

                    1/3
        + 2*LOG( - 2    + X)))/12

testint(1/(a*x**3-b),x);


                                  1/3      1/3
  1/3  2/3                     2*A   *X + B
(B   *A   *( - 2*SQRT(3)*ATAN(-----------------)
                                 1/3
                                B   *SQRT(3)

                    2/3  2    1/3  1/3      2/3
             - LOG(A   *X  + B   *A   *X + B   )

                      1/3      1/3
             + 2*LOG(A   *X - B   )))/(6*A*B)

testint(1/(x**4-2),x);


  1/4          1/4                1/4                 X
 2   *( - LOG(2    + X) + LOG( - 2    + X) - 2*ATAN(------))
                                                      1/4
                                                     2
-------------------------------------------------------------
                              8

testint(1/(5*x**4-1),x);


          1/4
(SQRT(5)*5

        1/4               1/4                  SQRT(5)*X
 *(LOG(5   *X - 1) - LOG(5   *X + 1) - 2*ATAN(-----------)))/20
                                                  1/4
                                                 5

testint(1/(3*x**4+7),x);


           1/4                      1/4                        2
(SQRT(6)*21   *( - LOG( - SQRT(2)*21   *X + SQRT(7) + SQRT(3)*X )

                                 1/4                        2
                 + LOG(SQRT(2)*21   *X + SQRT(7) + SQRT(3)*X )

                                     1/4
                           SQRT(2)*21    - 2*SQRT(3)*X
                 - 2*ATAN(-----------------------------)
                                            1/4
                                  SQRT(2)*21

                                     1/4
                           SQRT(2)*21    + 2*SQRT(3)*X
                 + 2*ATAN(-----------------------------)))/168
                                            1/4
                                  SQRT(2)*21

testint(1/(x**4+3*x**2-1),x);


(SQRT(2)*(3*SQRT(SQRT(13) - 3)*SQRT(13)

          *LOG( - SQRT(SQRT(13) - 3) + SQRT(2)*X) - 3

          *SQRT(SQRT(13) - 3)*SQRT(13)

          *LOG(SQRT(SQRT(13) - 3) + SQRT(2)*X) + 13

          *SQRT(SQRT(13) - 3)*LOG( - SQRT(SQRT(13) - 3) + SQRT(2)*X) 

          - 13*SQRT(SQRT(13) - 3)*LOG(SQRT(SQRT(13) - 3) + SQRT(2)*X)

           + 6*SQRT(SQRT(13) + 3)*SQRT(13)

                            2*X
          *ATAN(----------------------------)
                 SQRT(SQRT(13) + 3)*SQRT(2)

                                                    2*X
           - 26*SQRT(SQRT(13) + 3)*ATAN(----------------------------)
                                         SQRT(SQRT(13) + 3)*SQRT(2)

          ))/104

testint(1/(x**4-3*x**2-1),x);


(SQRT(2)*( - 6*SQRT(SQRT(13) - 3)*SQRT(13)

                            2*X
          *ATAN(----------------------------)
                 SQRT(SQRT(13) - 3)*SQRT(2)

                                                    2*X
           - 26*SQRT(SQRT(13) - 3)*ATAN(----------------------------)
                                         SQRT(SQRT(13) - 3)*SQRT(2)

           - 3*SQRT(SQRT(13) + 3)*SQRT(13)

          *LOG( - SQRT(SQRT(13) + 3) + SQRT(2)*X) + 3

          *SQRT(SQRT(13) + 3)*SQRT(13)

          *LOG(SQRT(SQRT(13) + 3) + SQRT(2)*X) + 13

          *SQRT(SQRT(13) + 3)*LOG( - SQRT(SQRT(13) + 3) + SQRT(2)*X) 

          - 13*SQRT(SQRT(13) + 3)*LOG(SQRT(SQRT(13) + 3) + SQRT(2)*X)

          ))/104

testint(1/(x**4-3*x**2+1),x);


( - SQRT(5)*LOG( - SQRT(5) + 2*X - 1)

  - SQRT(5)*LOG( - SQRT(5) + 2*X + 1)

  + SQRT(5)*LOG(SQRT(5) + 2*X - 1) + SQRT(5)*LOG(SQRT(5) + 2*X + 1)

  + 5*LOG( - SQRT(5) + 2*X - 1) - 5*LOG( - SQRT(5) + 2*X + 1)

  + 5*LOG(SQRT(5) + 2*X - 1) - 5*LOG(SQRT(5) + 2*X + 1))/20

testint(1/(x**4-4*x**2+1),x);


                                           X
(4*SQRT(SQRT(3) - 2)*SQRT(3)*ATAN(-------------------)
                                   SQRT(SQRT(3) - 2)

                                      X
  + 6*SQRT(SQRT(3) - 2)*ATAN(-------------------)
                              SQRT(SQRT(3) - 2)

  + 2*SQRT(SQRT(3) + 2)*SQRT(3)*LOG( - SQRT(SQRT(3) + 2) + X)

  - 2*SQRT(SQRT(3) + 2)*SQRT(3)*LOG(SQRT(SQRT(3) + 2) + X)

  - 3*SQRT(SQRT(3) + 2)*LOG( - SQRT(SQRT(3) + 2) + X)

  + 3*SQRT(SQRT(3) + 2)*LOG(SQRT(SQRT(3) + 2) + X))/12

testint(1/(x**4+4*x**2+1),x);


( - 2*SQRT(SQRT(3) - 2)*SQRT(3)*LOG( - SQRT(SQRT(3) - 2) + X)

  + 2*SQRT(SQRT(3) - 2)*SQRT(3)*LOG(SQRT(SQRT(3) - 2) + X)

  - 3*SQRT(SQRT(3) - 2)*LOG( - SQRT(SQRT(3) - 2) + X)

  + 3*SQRT(SQRT(3) - 2)*LOG(SQRT(SQRT(3) - 2) + X)

                                              X
  - 4*SQRT(SQRT(3) + 2)*SQRT(3)*ATAN(-------------------)
                                      SQRT(SQRT(3) + 2)

                                      X
  + 6*SQRT(SQRT(3) + 2)*ATAN(-------------------))/12
                              SQRT(SQRT(3) + 2)

testint(1/(x**4+x**2+2),x);


( - SQRT(2*SQRT(2) - 1)*SQRT(2)

                                            2
 *LOG( - SQRT(2*SQRT(2) - 1)*X + SQRT(2) + X ) + SQRT(2*SQRT(2) - 1)

                                                 2
 *SQRT(2)*LOG(SQRT(2*SQRT(2) - 1)*X + SQRT(2) + X ) - 4

                                                                2
 *SQRT(2*SQRT(2) - 1)*LOG( - SQRT(2*SQRT(2) - 1)*X + SQRT(2) + X )

                                                                 2
  + 4*SQRT(2*SQRT(2) - 1)*LOG(SQRT(2*SQRT(2) - 1)*X + SQRT(2) + X )

                                        SQRT(2*SQRT(2) - 1) - 2*X
  + 2*SQRT(2*SQRT(2) + 1)*SQRT(2)*ATAN(---------------------------)
                                           SQRT(2*SQRT(2) + 1)

                                        SQRT(2*SQRT(2) - 1) + 2*X
  - 2*SQRT(2*SQRT(2) + 1)*SQRT(2)*ATAN(---------------------------)
                                           SQRT(2*SQRT(2) + 1)

                                SQRT(2*SQRT(2) - 1) - 2*X
  - 8*SQRT(2*SQRT(2) + 1)*ATAN(---------------------------)
                                   SQRT(2*SQRT(2) + 1)

                                SQRT(2*SQRT(2) - 1) + 2*X
  + 8*SQRT(2*SQRT(2) + 1)*ATAN(---------------------------))/56
                                   SQRT(2*SQRT(2) + 1)

testint(1/(x**4-x**2+2),x);


                                        SQRT(2*SQRT(2) + 1) - 2*X
( - 2*SQRT(2*SQRT(2) - 1)*SQRT(2)*ATAN(---------------------------)
                                           SQRT(2*SQRT(2) - 1)

                                        SQRT(2*SQRT(2) + 1) + 2*X
  + 2*SQRT(2*SQRT(2) - 1)*SQRT(2)*ATAN(---------------------------)
                                           SQRT(2*SQRT(2) - 1)

                                SQRT(2*SQRT(2) + 1) - 2*X
  - 8*SQRT(2*SQRT(2) - 1)*ATAN(---------------------------)
                                   SQRT(2*SQRT(2) - 1)

                                SQRT(2*SQRT(2) + 1) + 2*X
  + 8*SQRT(2*SQRT(2) - 1)*ATAN(---------------------------) + 
                                   SQRT(2*SQRT(2) - 1)

 SQRT(2*SQRT(2) + 1)*SQRT(2)

                                            2
 *LOG( - SQRT(2*SQRT(2) + 1)*X + SQRT(2) + X ) - SQRT(2*SQRT(2) + 1)

                                                 2
 *SQRT(2)*LOG(SQRT(2*SQRT(2) + 1)*X + SQRT(2) + X ) - 4

                                                                2
 *SQRT(2*SQRT(2) + 1)*LOG( - SQRT(2*SQRT(2) + 1)*X + SQRT(2) + X )

                                                                 2
  + 4*SQRT(2*SQRT(2) + 1)*LOG(SQRT(2*SQRT(2) + 1)*X + SQRT(2) + X ))/

56

testint(1/(x**6-1),x);


                    2*X - 1                     2*X + 1
( - 2*SQRT(3)*ATAN(---------) - 2*SQRT(3)*ATAN(---------)
                    SQRT(3)                     SQRT(3)

         2                 2
  + LOG(X  - X + 1) - LOG(X  + X + 1) + 2*LOG(X - 1) - 2*LOG(X + 1))/

12

testint(1/(x**6-2),x);


                         1/6
  1/6                   2    - 2*X
(2   *(2*SQRT(3)*ATAN(--------------)
                        1/6
                       2   *SQRT(3)

                            1/6
                           2    + 2*X             1/6
        - 2*SQRT(3)*ATAN(--------------) - 2*LOG(2    + X)
                           1/6
                          2   *SQRT(3)

                    1/6                1/6      1/3    2
        + 2*LOG( - 2    + X) + LOG( - 2   *X + 2    + X )

               1/6      1/3    2
        - LOG(2   *X + 2    + X )))/24

testint(1/(x**6+2),x);


  1/6                     1/6              1/3    2
(2   *( - SQRT(3)*LOG( - 2   *SQRT(3)*X + 2    + X )

                       1/6              1/3    2
        + SQRT(3)*LOG(2   *SQRT(3)*X + 2    + X )

                   1/6                            1/6
                  2   *SQRT(3) - 2*X             2   *SQRT(3) + 2*X
        - 2*ATAN(--------------------) + 2*ATAN(--------------------)
                          1/6                            1/6
                         2                              2

                   X
        + 4*ATAN(------)))/24
                   1/6
                  2

testint(1/(x**8+1),x);


                                                          2
( - SQRT( - SQRT(2) + 2)*LOG( - SQRT( - SQRT(2) + 2)*X + X  + 1)

                                                       2
  + SQRT( - SQRT(2) + 2)*LOG(SQRT( - SQRT(2) + 2)*X + X  + 1)

                                 SQRT(SQRT(2) + 2) - 2*X
  - 2*SQRT( - SQRT(2) + 2)*ATAN(-------------------------)
                                  SQRT( - SQRT(2) + 2)

                                 SQRT(SQRT(2) + 2) + 2*X
  + 2*SQRT( - SQRT(2) + 2)*ATAN(-------------------------)
                                  SQRT( - SQRT(2) + 2)

                                                    2
  - SQRT(SQRT(2) + 2)*LOG( - SQRT(SQRT(2) + 2)*X + X  + 1)

                                                 2
  + SQRT(SQRT(2) + 2)*LOG(SQRT(SQRT(2) + 2)*X + X  + 1)

                              SQRT( - SQRT(2) + 2) - 2*X
  - 2*SQRT(SQRT(2) + 2)*ATAN(----------------------------)
                                  SQRT(SQRT(2) + 2)

                              SQRT( - SQRT(2) + 2) + 2*X
  + 2*SQRT(SQRT(2) + 2)*ATAN(----------------------------))/16
                                  SQRT(SQRT(2) + 2)

testint(1/(x**8-1),x);


                             2                                 2
(SQRT(2)*LOG( - SQRT(2)*X + X  + 1) - SQRT(2)*LOG(SQRT(2)*X + X  + 1)

                    SQRT(2) - 2*X                     SQRT(2) + 2*X
  + 2*SQRT(2)*ATAN(---------------) - 2*SQRT(2)*ATAN(---------------)
                       SQRT(2)                           SQRT(2)

  + 2*LOG(X - 1) - 2*LOG(X + 1) - 4*ATAN(X))/16

testint(1/(x**8-x**4+1),x);


( - SQRT( - SQRT(3) + 2)*SQRT(3)

                                   2
 *LOG( - SQRT( - SQRT(3) + 2)*X + X  + 1)

                                                               2
  + SQRT( - SQRT(3) + 2)*SQRT(3)*LOG(SQRT( - SQRT(3) + 2)*X + X  + 1)

                                         SQRT(SQRT(3) + 2) - 2*X
  - 2*SQRT( - SQRT(3) + 2)*SQRT(3)*ATAN(-------------------------)
                                          SQRT( - SQRT(3) + 2)

                                         SQRT(SQRT(3) + 2) + 2*X
  + 2*SQRT( - SQRT(3) + 2)*SQRT(3)*ATAN(-------------------------)
                                          SQRT( - SQRT(3) + 2)

                                                            2
  - 3*SQRT( - SQRT(3) + 2)*LOG( - SQRT( - SQRT(3) + 2)*X + X  + 1)

                                                         2
  + 3*SQRT( - SQRT(3) + 2)*LOG(SQRT( - SQRT(3) + 2)*X + X  + 1)

                                 SQRT(SQRT(3) + 2) - 2*X
  - 6*SQRT( - SQRT(3) + 2)*ATAN(-------------------------)
                                  SQRT( - SQRT(3) + 2)

                                 SQRT(SQRT(3) + 2) + 2*X
  + 6*SQRT( - SQRT(3) + 2)*ATAN(-------------------------)
                                  SQRT( - SQRT(3) + 2)

                                                            2
  + SQRT(SQRT(3) + 2)*SQRT(3)*LOG( - SQRT(SQRT(3) + 2)*X + X  + 1)

                                                         2
  - SQRT(SQRT(3) + 2)*SQRT(3)*LOG(SQRT(SQRT(3) + 2)*X + X  + 1)

                                      SQRT( - SQRT(3) + 2) - 2*X
  + 2*SQRT(SQRT(3) + 2)*SQRT(3)*ATAN(----------------------------)
                                          SQRT(SQRT(3) + 2)

                                      SQRT( - SQRT(3) + 2) + 2*X
  - 2*SQRT(SQRT(3) + 2)*SQRT(3)*ATAN(----------------------------)
                                          SQRT(SQRT(3) + 2)

                                                      2
  - 3*SQRT(SQRT(3) + 2)*LOG( - SQRT(SQRT(3) + 2)*X + X  + 1)

                                                   2
  + 3*SQRT(SQRT(3) + 2)*LOG(SQRT(SQRT(3) + 2)*X + X  + 1)

                              SQRT( - SQRT(3) + 2) - 2*X
  - 6*SQRT(SQRT(3) + 2)*ATAN(----------------------------)
                                  SQRT(SQRT(3) + 2)

                              SQRT( - SQRT(3) + 2) + 2*X
  + 6*SQRT(SQRT(3) + 2)*ATAN(----------------------------))/24
                                  SQRT(SQRT(3) + 2)

testint(x**7/(x**12+1),x);


(2*SQRT(SQRT(3) + 2)*SQRT( - SQRT(3) + 2)*SQRT(3)

        SQRT( - SQRT(3) + 2) - 2*X
 *ATAN(----------------------------) + 2*SQRT(SQRT(3) + 2)
            SQRT(SQRT(3) + 2)

                                     SQRT( - SQRT(3) + 2) + 2*X
 *SQRT( - SQRT(3) + 2)*SQRT(3)*ATAN(----------------------------) - 2
                                         SQRT(SQRT(3) + 2)

 *SQRT(SQRT(3) + 2)*SQRT( - SQRT(3) + 2)*SQRT(3)

        SQRT(SQRT(3) + 2) - 2*X
 *ATAN(-------------------------) - 2*SQRT(SQRT(3) + 2)
         SQRT( - SQRT(3) + 2)

                                     SQRT(SQRT(3) + 2) + 2*X
 *SQRT( - SQRT(3) + 2)*SQRT(3)*ATAN(-------------------------)
                                      SQRT( - SQRT(3) + 2)

                                     2
  + LOG( - SQRT( - SQRT(3) + 2)*X + X  + 1)

                                  2
  + LOG( - SQRT(SQRT(3) + 2)*X + X  + 1)

                          2
  - 2*LOG( - SQRT(2)*X + X  + 1)

                                  2
  + LOG(SQRT( - SQRT(3) + 2)*X + X  + 1)

                               2                           2
  + LOG(SQRT(SQRT(3) + 2)*X + X  + 1) - 2*LOG(SQRT(2)*X + X  + 1))/24


% Examples involving logarithms.

testint(log x,x);


X*(LOG(X) - 1)

testint(x*log x,x);


  2
 X *(2*LOG(X) - 1)
-------------------
         4

testint(x**2*log x,x);


  3
 X *(3*LOG(X) - 1)
-------------------
         9

testint(x**p*log x,x);


  P
 X *X*(LOG(X)*P + LOG(X) - 1)
------------------------------
          2
         P  + 2*P + 1

testint((log x)**2,x);


         2
X*(LOG(X)  - 2*LOG(X) + 2)

testint(x**9*log x**11,x);


  10                 11                  10                  9
(X  *(15625000*LOG(X)   - 17187500*LOG(X)   + 17187500*LOG(X)

                        8                  7                 6
       - 15468750*LOG(X)  + 12375000*LOG(X)  - 8662500*LOG(X)

                       5                 4                 3
       + 5197500*LOG(X)  - 2598750*LOG(X)  + 1039500*LOG(X)

                      2
       - 311850*LOG(X)  + 62370*LOG(X) - 6237))/156250000

testint(log x**2/x,x);


       3
 LOG(X)
---------
    3

testint(1/log x,x);


       1
INT(--------,X)
     LOG(X)

testint(1/log(x+1),x);


                 X
INT(---------------------------,X) + LOG(LOG(X + 1))
     LOG(X + 1)*X + LOG(X + 1)

testint(1/(x*log x),x);


LOG(LOG(X))

testint(1/(x*log x)**2,x);


              1
  - (INT(-----------,X)*LOG(X)*X + 1)
                  2
          LOG(X)*X
--------------------------------------
               LOG(X)*X

testint((log x)**p/x,x);


       P
 LOG(X) *LOG(X)
----------------
     P + 1

testint(log x *(a*x+b),x);


 X*(2*LOG(X)*A*X + 4*LOG(X)*B - A*X - 4*B)
-------------------------------------------
                     4

testint((a*x+b)**2*log x,x);


              2  2                                2      2  2
(X*(6*LOG(X)*A *X  + 18*LOG(X)*A*B*X + 18*LOG(X)*B  - 2*A *X

                     2
     - 9*A*B*X - 18*B ))/18

testint(log x/(a*x+b)**2,x);


  - LOG(A*X + B)*A*X - LOG(A*X + B)*B + LOG(X)*A*X
---------------------------------------------------
                   A*B*(A*X + B)

testint(x*log (a*x+b),x);


                 2  2                   2    2  2
 2*LOG(A*X + B)*A *X  - 2*LOG(A*X + B)*B  - A *X  + 2*A*B*X
------------------------------------------------------------
                               2
                            4*A

testint(x**2*log(a*x+b),x);


                 3  3                   3      3  3      2    2
(6*LOG(A*X + B)*A *X  + 6*LOG(A*X + B)*B  - 2*A *X  + 3*A *B*X

         2         3
  - 6*A*B *X)/(18*A )

testint(log(x**2+a**2),x);


     2    2              X
LOG(A  + X )*X + 2*ATAN(---)*A - 2*X
                         A

testint(x*log(x**2+a**2),x);


      2    2   2        2    2   2    2
 LOG(A  + X )*A  + LOG(A  + X )*X  - X
----------------------------------------
                   2

testint(x**2*log(x**2+a**2),x);


        2    2   3           X    3      2        3
 3*LOG(A  + X )*X  - 6*ATAN(---)*A  + 6*A *X - 2*X
                             A
----------------------------------------------------
                         9

testint(x**4*log(x**2+a**2),x);


         2    2   5            X    5       4         2  3      5
 15*LOG(A  + X )*X  + 30*ATAN(---)*A  - 30*A *X + 10*A *X  - 6*X
                               A
------------------------------------------------------------------
                                75

testint(log(x**2-a**2),x);


           2    2              2    2
 - LOG( - A  + X )*A + LOG( - A  + X )*X + 2*LOG( - A - X)*A - 2*X

testint(log(log(log(log(x)))),x);


                         1
 - INT(-------------------------------------,X)
        LOG(LOG(LOG(X)))*LOG(LOG(X))*LOG(X)

 + LOG(LOG(LOG(LOG(X))))*X


% Examples involving circular functions.

testint(sin x,x);


 - COS(X)
 % 2.01 #5;
testint(cos x,x);


SIN(X)
 %     #6;
testint(tan x,x);


           2
 LOG(TAN(X)  + 1)
------------------
        2
 %     #11;
testint(1/tan(x),x);


              2
  - LOG(TAN(X)  + 1) + 2*LOG(TAN(X))
-------------------------------------
                  2
 % 2.01 #12;
testint(1/(1+tan(x))**2,x);


              2                         2
( - LOG(TAN(X)  + 1)*TAN(X) - LOG(TAN(X)  + 1)

  + 2*LOG(TAN(X) + 1)*TAN(X) + 2*LOG(TAN(X) + 1) + 2*TAN(X))/(4

   *(TAN(X) + 1))

testint(1/cos x,x);


            X                   X
 - LOG(TAN(---) - 1) + LOG(TAN(---) + 1)
            2                   2

testint(1/sin x,x);


         X
LOG(TAN(---))
         2

testint(sin x**2,x);


  - SIN(X)*COS(X) + X
----------------------
          2

testint(x**3*sin(x**2),x);


      2         2   2
 SIN(X ) - COS(X )*X
----------------------
          2

testint(sin x**3,x);


          2
  - SIN(X) *COS(X) - 2*COS(X) + 2
----------------------------------
                3

testint(sin x**p,x);


          P
INT(SIN(X) ,X)

testint((sin x**2+1)**2*cos x,x);


                 4            2
 SIN(X)*(3*SIN(X)  + 10*SIN(X)  + 15)
--------------------------------------
                  15

testint(cos x**2,x);


 SIN(X)*COS(X) + X
-------------------
         2

testint(cos x**3,x);


                  2
 SIN(X)*( - SIN(X)  + 3)
-------------------------
            3

testint(sin(a*x+b),x);


  - COS(A*X + B)
-----------------
        A

testint(1/cos x**2,x);


 SIN(X)
--------
 COS(X)

testint(sin x*sin(2*x),x);


 SIN(2*X)*COS(X) - 2*SIN(X)*COS(2*X)
-------------------------------------
                  3

testint(x*sin x,x);


SIN(X) - COS(X)*X

testint(x**2*sin x,x);


                     2
2*SIN(X)*X - COS(X)*X  + 2*COS(X)

testint(x*sin x**2,x);


       2                        2
 SIN(X)  - 2*SIN(X)*COS(X)*X + X  - 2
--------------------------------------
                  4

testint(x**2*sin x**2,x);


         2                      2                        3
 6*SIN(X) *X - 6*SIN(X)*COS(X)*X  + 3*SIN(X)*COS(X) + 2*X  - 3*X
-----------------------------------------------------------------
                               12

testint(x*sin x**3,x);


       3           2
 SIN(X)  - 3*SIN(X) *COS(X)*X + 6*SIN(X) - 6*COS(X)*X
------------------------------------------------------
                          9

testint(x*cos x,x);


SIN(X)*X + COS(X)

testint(x**2*cos x,x);


        2
SIN(X)*X  - 2*SIN(X) + 2*COS(X)*X

testint(x*cos x**2,x);


          2                        2
  - SIN(X)  + 2*SIN(X)*COS(X)*X + X  + 2
-----------------------------------------
                    4

testint(x**2*cos x**2,x);


            2                      2                        3
  - 6*SIN(X) *X + 6*SIN(X)*COS(X)*X  - 3*SIN(X)*COS(X) + 2*X  + 3*X
--------------------------------------------------------------------
                                 12

testint(x*cos x**3,x);


            3           2
  - 3*SIN(X) *X - SIN(X) *COS(X) + 9*SIN(X)*X + 7*COS(X) + 1
-------------------------------------------------------------
                              9

testint(sin x/x,x);


     SIN(X)
INT(--------,X)
       X

testint(cos x/x,x);


     COS(X)
INT(--------,X)
       X

testint(sin x/x**2,x);


     SIN(X)
INT(--------,X)
        2
       X

testint(sin x**2/x,x);


           2
     SIN(X)
INT(---------,X)
        X

testint(tan x**3,x);


              2              2
  - LOG(TAN(X)  + 1) + TAN(X)
-------------------------------
               2

% z := a+b*x;
testint(sin z,x);


  - COS(A + B*X)
-----------------
        B

testint(cos z,x);


 SIN(A + B*X)
--------------
      B

testint(tan z,x);


                 2
 LOG(TAN(A + B*X)  + 1)
------------------------
          2*B

testint(1/tan z,x);


                    2
  - LOG(TAN(A + B*X)  + 1) + 2*LOG(TAN(A + B*X))
-------------------------------------------------
                       2*B

testint(1/sin z,x);


          A + B*X
 LOG(TAN(---------))
             2
---------------------
          B

testint(1/cos z,x);


             A + B*X                   A + B*X
  - LOG(TAN(---------) - 1) + LOG(TAN(---------) + 1)
                2                         2
------------------------------------------------------
                          B

testint(sin z**2,x);


  - SIN(A + B*X)*COS(A + B*X) + B*X
------------------------------------
                2*B

testint(sin z**3,x);


                2
  - SIN(A + B*X) *COS(A + B*X) - 2*COS(A + B*X) + 2
----------------------------------------------------
                        3*B

testint(cos z**2,x);


 SIN(A + B*X)*COS(A + B*X) + B*X
---------------------------------
               2*B

testint(cos z**3,x);


                              2
 SIN(A + B*X)*( - SIN(A + B*X)  + 3)
-------------------------------------
                 3*B

testint(1/cos z**2,x);


  SIN(A + B*X)
----------------
 COS(A + B*X)*B

testint(1/(1+cos x),x);


     X
TAN(---)
     2

testint(1/(1-cos x),x);


    - 1
----------
      X
 TAN(---)
      2

testint(1/(1+sin x),x);


         X
  2*TAN(---)
         2
--------------
      X
 TAN(---) + 1
      2

testint(1/(1-sin x),x);


           X
  - 2*TAN(---)
           2
---------------
      X
 TAN(---) - 1
      2

testint(1/(a+b*sin x),x);


                            X
                       TAN(---)*A + B
         2    2             2
 2*SQRT(A  - B )*ATAN(----------------)
                             2    2
                       SQRT(A  - B )
----------------------------------------
                 2    2
                A  - B

testint(1/(a+b*sin x+cos x),x);


                                X            X
                           TAN(---)*A - TAN(---) + B
         2    2                 2            2
 2*SQRT(A  - B  - 1)*ATAN(---------------------------)
                                     2    2
                               SQRT(A  - B  - 1)
-------------------------------------------------------
                       2    2
                      A  - B  - 1

testint(x**2*sin z**2,x);


               2                                    2  2
(6*SIN(A + B*X) *B*X - 6*SIN(A + B*X)*COS(A + B*X)*B *X

                                           3  3               3
  + 3*SIN(A + B*X)*COS(A + B*X) + 9*A + 2*B *X  - 3*B*X)/(12*B )

testint(cos x*cos(2*x),x);


 2*SIN(2*X)*COS(X) - SIN(X)*COS(2*X)
-------------------------------------
                  3

testint(x**2*cos z**2,x);


                  2                                    2  2
( - 6*SIN(A + B*X) *B*X + 6*SIN(A + B*X)*COS(A + B*X)*B *X

                                     3  3               3
  - 3*SIN(A + B*X)*COS(A + B*X) + 2*B *X  + 3*B*X)/(12*B )

testint(1/tan x**3,x);


           2            2                       2
 LOG(TAN(X)  + 1)*TAN(X)  - 2*LOG(TAN(X))*TAN(X)  - 1
------------------------------------------------------
                              2
                      2*TAN(X)

testint(x**3*tan(x)**4,x);


                2                  2                3  3
(48*INT(TAN(X)*X ,X) - 6*LOG(TAN(X)  + 1) + 4*TAN(X) *X

            2  2              3                    4      2
  - 6*TAN(X) *X  - 12*TAN(X)*X  + 12*TAN(X)*X + 3*X  - 6*X )/12

testint(x**3*tan(x)**6,x);


                    2                   2                 5  3
( - 276*INT(TAN(X)*X ,X) + 60*LOG(TAN(X)  + 1) + 12*TAN(X) *X

            4  2            3  3           3              2  2
  - 9*TAN(X) *X  - 20*TAN(X) *X  + 6*TAN(X) *X + 48*TAN(X) *X

            2              3                      4       2
  - 3*TAN(X)  + 60*TAN(X)*X  - 114*TAN(X)*X - 15*X  + 57*X )/60

testint(x*tan(x)**2,x);


              2                      2
  - LOG(TAN(X)  + 1) + 2*TAN(X)*X - X
---------------------------------------
                   2

testint(sin(2*x)*cos(3*x),x);


 3*SIN(3*X)*SIN(2*X) + 2*COS(3*X)*COS(2*X)
-------------------------------------------
                     5

testint(sin x**2*cos x**2,x);


         3
 2*SIN(X) *COS(X) - SIN(X)*COS(X) + X
--------------------------------------
                  8

testint(1/(sin x**2*cos x**2),x);


         2
 2*SIN(X)  - 1
---------------
 SIN(X)*COS(X)

testint(d**x*sin x,x);


  X
 D *(SIN(X)*LOG(D) - COS(X))
-----------------------------
               2
         LOG(D)  + 1

testint(d**x*cos x,x);


  X
 D *(SIN(X) + COS(X)*LOG(D))
-----------------------------
               2
         LOG(D)  + 1

testint(x*d**x*sin x,x);


  X               3                  2
(D *(SIN(X)*LOG(D) *X - SIN(X)*LOG(D)  + SIN(X)*LOG(D)*X + SIN(X)

                     2                                         4
      - COS(X)*LOG(D) *X + 2*COS(X)*LOG(D) - COS(X)*X))/(LOG(D)

              2
    + 2*LOG(D)  + 1)

testint(x*d**x*cos x,x);


  X               2                                               3
(D *(SIN(X)*LOG(D) *X - 2*SIN(X)*LOG(D) + SIN(X)*X + COS(X)*LOG(D) *X

                     2                                     4
      - COS(X)*LOG(D)  + COS(X)*LOG(D)*X + COS(X)))/(LOG(D)

              2
    + 2*LOG(D)  + 1)

testint(x**2*d**x*sin x,x);


  X               5  2                  4                    3  2
(D *(SIN(X)*LOG(D) *X  - 2*SIN(X)*LOG(D) *X + 2*SIN(X)*LOG(D) *X

                       3                  2
      + 2*SIN(X)*LOG(D)  + SIN(X)*LOG(D)*X  - 6*SIN(X)*LOG(D)

                                  4  2                  3
      + 2*SIN(X)*X - COS(X)*LOG(D) *X  + 4*COS(X)*LOG(D) *X

                       2  2                  2
      - 2*COS(X)*LOG(D) *X  - 6*COS(X)*LOG(D)  + 4*COS(X)*LOG(D)*X

                2                     6           4           2
      - COS(X)*X  + 2*COS(X)))/(LOG(D)  + 3*LOG(D)  + 3*LOG(D)  + 1)

testint(x**2*d**x*cos x,x);


  X               4  2                  3                    2  2
(D *(SIN(X)*LOG(D) *X  - 4*SIN(X)*LOG(D) *X + 2*SIN(X)*LOG(D) *X

                       2                               2
      + 6*SIN(X)*LOG(D)  - 4*SIN(X)*LOG(D)*X + SIN(X)*X  - 2*SIN(X)

                     5  2                  4                    3  2
      + COS(X)*LOG(D) *X  - 2*COS(X)*LOG(D) *X + 2*COS(X)*LOG(D) *X

                       3                  2
      + 2*COS(X)*LOG(D)  + COS(X)*LOG(D)*X  - 6*COS(X)*LOG(D)

                            6           4           2
      + 2*COS(X)*X))/(LOG(D)  + 3*LOG(D)  + 3*LOG(D)  + 1)

testint(x**3*d**x*sin x,x);


  X               7  3                  6  2                  5  3
(D *(SIN(X)*LOG(D) *X  - 3*SIN(X)*LOG(D) *X  + 3*SIN(X)*LOG(D) *X

                       5                    4  2                  4
      + 6*SIN(X)*LOG(D) *X - 3*SIN(X)*LOG(D) *X  - 6*SIN(X)*LOG(D)

                       3  3                   3
      + 3*SIN(X)*LOG(D) *X  - 12*SIN(X)*LOG(D) *X

                       2  2                   2                  3
      + 3*SIN(X)*LOG(D) *X  + 36*SIN(X)*LOG(D)  + SIN(X)*LOG(D)*X

                                       2
      - 18*SIN(X)*LOG(D)*X + 3*SIN(X)*X  - 6*SIN(X)

                     6  3                  5  2                  4  3
      - COS(X)*LOG(D) *X  + 6*COS(X)*LOG(D) *X  - 3*COS(X)*LOG(D) *X

                        4                     3  2
      - 18*COS(X)*LOG(D) *X + 12*COS(X)*LOG(D) *X

                        3                  2  3                   2
      + 24*COS(X)*LOG(D)  - 3*COS(X)*LOG(D) *X  - 12*COS(X)*LOG(D) *X

                         2                              3
      + 6*COS(X)*LOG(D)*X  - 24*COS(X)*LOG(D) - COS(X)*X

                            8           6           4           2
      + 6*COS(X)*X))/(LOG(D)  + 4*LOG(D)  + 6*LOG(D)  + 4*LOG(D)  + 1

   )

testint(x**3*d**x*cos x,x);


  X               6  3                  5  2                  4  3
(D *(SIN(X)*LOG(D) *X  - 6*SIN(X)*LOG(D) *X  + 3*SIN(X)*LOG(D) *X

                        4                     3  2
      + 18*SIN(X)*LOG(D) *X - 12*SIN(X)*LOG(D) *X

                        3                  2  3                   2
      - 24*SIN(X)*LOG(D)  + 3*SIN(X)*LOG(D) *X  + 12*SIN(X)*LOG(D) *X

                         2                              3
      - 6*SIN(X)*LOG(D)*X  + 24*SIN(X)*LOG(D) + SIN(X)*X

                                  7  3                  6  2
      - 6*SIN(X)*X + COS(X)*LOG(D) *X  - 3*COS(X)*LOG(D) *X

                       5  3                  5
      + 3*COS(X)*LOG(D) *X  + 6*COS(X)*LOG(D) *X

                       4  2                  4                  3  3
      - 3*COS(X)*LOG(D) *X  - 6*COS(X)*LOG(D)  + 3*COS(X)*LOG(D) *X

                        3                    2  2                   2
      - 12*COS(X)*LOG(D) *X + 3*COS(X)*LOG(D) *X  + 36*COS(X)*LOG(D)

                       3                                  2
      + COS(X)*LOG(D)*X  - 18*COS(X)*LOG(D)*X + 3*COS(X)*X

                          8           6           4           2
      - 6*COS(X)))/(LOG(D)  + 4*LOG(D)  + 6*LOG(D)  + 4*LOG(D)  + 1)

testint(sin x*sin(2*x)*sin(3*x),x);


(6*SIN(3*X)*SIN(2*X)*SIN(X)*X + 3*SIN(3*X)*SIN(X)*COS(2*X)

  - 6*SIN(3*X)*COS(2*X)*COS(X)*X - 8*SIN(2*X)*SIN(X)*COS(3*X)

  + 6*SIN(2*X)*COS(3*X)*COS(X)*X + 6*SIN(X)*COS(3*X)*COS(2*X)*X

  - COS(3*X)*COS(2*X)*COS(X))/24

testint(cos x*cos(2*x)*cos(3*x),x);


(SIN(3*X)*SIN(2*X)*SIN(X) + 6*SIN(3*X)*SIN(2*X)*COS(X)*X

  + 6*SIN(3*X)*SIN(X)*COS(2*X)*X + 8*SIN(3*X)*COS(2*X)*COS(X)

  - 6*SIN(2*X)*SIN(X)*COS(3*X)*X - 3*SIN(2*X)*COS(3*X)*COS(X)

  + 6*COS(3*X)*COS(2*X)*COS(X)*X)/24

testint(sin(x*kx)**3*x**2,x);


            3                   2            2   2
(6*SIN(X*KX) *X*KX - 9*SIN(X*KX) *COS(X*KX)*X *KX

               2                                               2   2
  + 2*SIN(X*KX) *COS(X*KX) + 36*SIN(X*KX)*X*KX - 18*COS(X*KX)*X *KX

                             3
  + 40*COS(X*KX) + 16)/(27*KX )

testint(x*cos(xi/sin(x))*cos(x)/sin(x)**2,x);


            XI
     COS(--------)*COS(X)*X
          SIN(X)
INT(------------------------,X)
                  2
            SIN(X)


% Mixed angles and half angles.

int(cos(x)/(sin(x)*tan(x/2)),x);


          X
  - (TAN(---)*X + 1)
          2
---------------------
           X
      TAN(---)
           2


% This integral produces a messy result because the code for
% converting half angle tans to sin and cos is not effective enough.

testint(sin(a*x)/(b+c*sin(a*x))**2,x);


                                        A*X
                                   TAN(-----)*B + C
            2    2                       2             2
( - 2*SQRT(B  - C )*SIN(A*X)*ATAN(------------------)*C
                                          2    2
                                    SQRT(B  - C )

                               A*X
                          TAN(-----)*B + C
            2    2              2                            3
  - 2*SQRT(B  - C )*ATAN(------------------)*B*C - COS(A*X)*B
                                 2    2
                           SQRT(B  - C )

                2                4                 2  3             5
  + COS(A*X)*B*C )/(A*(SIN(A*X)*B *C - 2*SIN(A*X)*B *C  + SIN(A*X)*C

          5      3  2      4
       + B  - 2*B *C  + B*C ))


% Examples involving logarithms and circular functions.

testint(sin log x,x);


 X*(SIN(LOG(X)) - COS(LOG(X)))
-------------------------------
               2

testint(cos log x,x);


 X*(SIN(LOG(X)) + COS(LOG(X)))
-------------------------------
               2


% Examples involving exponentials.

testint(e**x,x);


 X
E
 % 2.01 #3;
testint(a**x,x);


    X
   A
--------
 LOG(A)
 % 2.01 #4;
testint(e**(a*x),x);


  A*X
 E
------
  A

testint(e**(a*x)/x,x);


      A*X
     E
INT(------,X)
      X

testint(1/(a+b*e**(m*x)),x);


         M*X
  - LOG(E   *B + A) + M*X
--------------------------
           A*M

testint(e**(2*x)/(1+e**x),x);


 X        X
E  - LOG(E  + 1)

testint(e**(2*x)*e**(a*x),x);


  A*X + 2*X
 E
------------
   A + 2

testint(1/(a*e**(m*x)+b*e**(-m*x)),x);


                            M*X
                           E   *A
 SQRT(B)*SQRT(A)*ATAN(-----------------)
                       SQRT(B)*SQRT(A)
-----------------------------------------
                  A*B*M

testint(x*e**(a*x),x);


  A*X
 E   *(A*X - 1)
----------------
        2
       A

testint(x**20*e**x,x);


 X   20       19        18         17           16            15
E *(X   - 20*X   + 380*X   - 6840*X   + 116280*X   - 1860480*X

                 14              13               12
     + 27907200*X   - 390700800*X   + 5079110400*X

                    11                 10                  9
     - 60949324800*X   + 670442572800*X   - 6704425728000*X

                       8                    7                     6
     + 60339831552000*X  - 482718652416000*X  + 3379030566912000*X

                          5                       4
     - 20274183401472000*X  + 101370917007360000*X

                           3                        2
     - 405483668029440000*X  + 1216451004088320000*X

     - 2432902008176640000*X + 2432902008176640000)

testint(a**x/b**x,x);


           X
          A
----------------------
  X
 B *(LOG(A) - LOG(B))

testint(a**x*b**x,x);


       X  X
      B *A
-----------------
 LOG(A) + LOG(B)

testint(a**x/x**2,x);


      X
     A
INT(----,X)
      2
     X

testint(x*a**x/(1+b*x)**2,x);


                   X
  X               A
(A  - INT(-------------------,X)*LOG(A)*B*X
            2  2
           B *X  + 2*B*X + 1

                 X
                A
  - INT(-------------------,X)*LOG(A)
          2  2
         B *X  + 2*B*X + 1

                 X                                 X
                A               2                 A
  + INT(-------------------,X)*B *X + INT(-------------------,X)*B)/(
          2  2                              2  2
         B *X  + 2*B*X + 1                 B *X  + 2*B*X + 1

   LOG(A)*B*(B*X + 1))

testint(x*e**(a*x)/(1+a*x)**2,x);


      A*X
     E
--------------
  2
 A *(A*X + 1)

testint(x*k**(x**2),x);


     2
    X
   K
----------
 2*LOG(K)

testint(e**(x**2),x);


      2
     X
INT(E  ,X)

testint(x*e**(x**2),x);


   2
  X
 E
-----
  2

testint((x+1)*e**(1/x)/x**4,x);


  1/X      2
 E   *( - X  + X - 1)
----------------------
           2
          X

testint((2*x**3+x)*(e**(x**2))**2*e**(1-x*e**(x**2))/(1-x*e**(x**2))**2,
        x);


         - E
--------------------
    2
   X       2
  E  *X   X
 E     *(E  *X - 1)

testint(e**(e**(e**(e**x))),x);


        X
       E
      E
     E
INT(E    ,X)


% Examples involving exponentials and logarithms.

testint(e**x*log x,x);


                  X
 X               E
E *LOG(X) - INT(----,X)
                 X

testint(x*e**x*log x,x);


                                     X
 X             X           X        E
E *LOG(X)*X - E *LOG(X) - E  + INT(----,X)
                                    X

testint(e**(2*x)*log(e**x),x);


  2*X
 E   *(2*X - 1)
----------------
       4


% Examples involving square roots.

testint(sqrt(2)*x**2 + 2*x,x);


  2
 X *(SQRT(2)*X + 3)
--------------------
         3

testint(log x/sqrt(a*x+b),x);


(2

                                                 SQRT(A*X + B)
 *(SQRT(A*X + B)*LOG(X) - 2*SQRT(A*X + B) - INT(---------------,X)*B)
                                                     2
                                                  A*X  + B*X

 )/A

u:=sqrt(a+b*x);


U := SQRT(A + B*X)

v:=sqrt(c+d*x);


V := SQRT(C + D*X)

testint(u*v,x);


(2*SQRT(C + D*X)*SQRT(A + B*X)*A*D

  + 2*SQRT(C + D*X)*SQRT(A + B*X)*B*C

  + 4*SQRT(C + D*X)*SQRT(A + B*X)*B*D*X

         SQRT(C + D*X)*SQRT(A + B*X)       2  2
  - INT(------------------------------,X)*A *D
                                    2
         A*C + A*D*X + B*C*X + B*D*X

           SQRT(C + D*X)*SQRT(A + B*X)
  + 2*INT(------------------------------,X)*A*B*C*D
                                      2
           A*C + A*D*X + B*C*X + B*D*X

         SQRT(C + D*X)*SQRT(A + B*X)       2  2
  - INT(------------------------------,X)*B *C )/(8*B*D)
                                    2
         A*C + A*D*X + B*C*X + B*D*X

testint(u,x);


 2*SQRT(A + B*X)*(A + B*X)
---------------------------
            3*B

testint(x*u,x);


                        2              2  2
 2*SQRT(A + B*X)*( - 2*A  + A*B*X + 3*B *X )
---------------------------------------------
                        2
                    15*B

testint(x**2*u,x);


                     3      2            2  2       3  3
 2*SQRT(A + B*X)*(8*A  - 4*A *B*X + 3*A*B *X  + 15*B *X )
----------------------------------------------------------
                               3
                          105*B

testint(u/x,x);


                       SQRT(A + B*X)
2*SQRT(A + B*X) + INT(---------------,X)*A
                                 2
                        A*X + B*X

testint(u/x**2,x);


                           SQRT(A + B*X)
  - 2*SQRT(A + B*X) + INT(---------------,X)*B*X
                                     2
                            A*X + B*X
-------------------------------------------------
                       2*X

testint(1/u,x);


 2*SQRT(A + B*X)
-----------------
        B

testint(x/u,x);


 2*SQRT(A + B*X)*( - 2*A + B*X)
--------------------------------
                 2
              3*B

testint(x**2/u,x);


                     2                2  2
 2*SQRT(A + B*X)*(8*A  - 4*A*B*X + 3*B *X )
--------------------------------------------
                       3
                   15*B

testint(1/(x*u),x);


     SQRT(A + B*X)
INT(---------------,X)
               2
      A*X + B*X

testint(1/(x**2*u),x);


                           SQRT(A + B*X)
  - 2*SQRT(A + B*X) - INT(---------------,X)*B*X
                                     2
                            A*X + B*X
-------------------------------------------------
                      2*A*X

testint(u**p,x);


            P/2
 2*(A + B*X)   *(A + B*X)
--------------------------
        B*(P + 2)

testint(x*u**p,x);


            P/2        2              2    2      2  2
 2*(A + B*X)   *( - 2*A  + A*B*P*X + B *P*X  + 2*B *X )
--------------------------------------------------------
                    2   2
                   B *(P  + 6*P + 8)

testint(atan((-sqrt(2)+2*x)/sqrt(2)),x);


                                2
( - SQRT(2)*LOG( - SQRT(2)*X + X  + 1)

                    SQRT(2) - 2*X             SQRT(2) - 2*X
  + 2*SQRT(2)*ATAN(---------------) - 4*ATAN(---------------)*X)/4
                       SQRT(2)                   SQRT(2)

testint(1/sqrt(x**2-1),x);


           2
     SQRT(X  - 1)
INT(--------------,X)
         2
        X  - 1

testint(sqrt(x+1)*sqrt x,x);


(4*SQRT(X)*SQRT(X + 1)*X + 2*SQRT(X)*SQRT(X + 1)

         SQRT(X)*SQRT(X + 1)
  - INT(---------------------,X))/8
                2
               X  + X


% Examples from James Davenport's thesis:

testint(1/sqrt(x**2-1)+10/sqrt(x**2-4),x);


              2       2                  2       2
        SQRT(X  - 4)*X             SQRT(X  - 1)*X
10*INT(-----------------,X) + INT(-----------------,X)
          4      2                   4      2
         X  - 5*X  + 4              X  - 5*X  + 4

                 2                          2
           SQRT(X  - 4)               SQRT(X  - 1)
 - 10*INT(---------------,X) - 4*INT(---------------,X)
            4      2                   4      2
           X  - 5*X  + 4              X  - 5*X  + 4
      % p. 173
testint(sqrt(x+sqrt(x**2+a**2))/x,x);


                2    2
     SQRT(SQRT(A  + X ) + X)
INT(-------------------------,X)
                X


% Examples generated by differentiating various functions.

testint(df(sqrt(1+x**2)/(1-x),x),x);


          2
  - SQRT(X  + 1)
-----------------
      X - 1

testint(df(log(x+sqrt(1+x**2)),x),x);


           2
     SQRT(X  + 1)
INT(--------------,X)
         2
        X  + 1

testint(df(sqrt(x)+sqrt(x+1)+sqrt(x+2),x),x);


SQRT(X + 2) + SQRT(X + 1) + SQRT(X)

testint(df(sqrt(x**5-2*x+1)-sqrt(x**3+1),x),x);


      5                    3
SQRT(X  - 2*X + 1) - SQRT(X  + 1)


% Another such example from James Davenport's thesis (p. 146).
% It contains a point of order 3, which is found by use of Mazur's
% bound on the torsion of elliptic curves over the rationals;

testint(df(log(1+sqrt(x**3+1)),x),x);


                  3
            SQRT(X  + 1)
 3*( - INT(--------------,X) + LOG(X))
                4
               X  + X
---------------------------------------
                   2


% Examples quoted by Joel Moses:

testint(1/sqrt(2*h*r**2-alpha**2),r);


               2        2
     SQRT(2*H*R  - ALPHA )
INT(-----------------------,R)
             2        2
        2*H*R  - ALPHA

testint(1/(r*sqrt(2*h*r**2-alpha**2-epsilon**2)),r);


               2        2          2
     SQRT(2*H*R  - ALPHA  - EPSILON )
INT(----------------------------------,R)
           3          2            2
      2*H*R  - R*ALPHA  - R*EPSILON

testint(1/(r*sqrt(2*h*r**2-alpha**2-2*k*r)),r);


               2                2
     SQRT(2*H*R  - 2*K*R - ALPHA )
INT(-------------------------------,R)
           3        2          2
      2*H*R  - 2*K*R  - R*ALPHA

testint(1/(r*sqrt(2*h*r**2-alpha**2-epsilon**2-2*k*r)),r);


               2                2          2
     SQRT(2*H*R  - 2*K*R - ALPHA  - EPSILON )
INT(------------------------------------------,R)
          3        2          2            2
     2*H*R  - 2*K*R  - R*ALPHA  - R*EPSILON

testint(r/sqrt(2*e*r**2-alpha**2),r);


           2        2
 SQRT(2*E*R  - ALPHA )
-----------------------
          2*E

testint(r/sqrt(2*e*r**2-alpha**2-epsilon**2),r);


           2        2          2
 SQRT(2*E*R  - ALPHA  - EPSILON )
----------------------------------
               2*E

testint(r/sqrt(2*e*r**2-alpha**2-2*k*r**4),r);


               2        4        2
     SQRT(2*E*R  - 2*K*R  - ALPHA )*R
INT(----------------------------------,R)
              2        4        2
         2*E*R  - 2*K*R  - ALPHA

testint(r/sqrt(2*e*r**2-alpha**2-2*k*r),r);


           2                2
(SQRT(2*E*R  - 2*K*R - ALPHA )

                   2                2
         SQRT(2*E*R  - 2*K*R - ALPHA )
  + INT(-------------------------------,R)*K)/(2*E)
                 2                2
            2*E*R  - 2*K*R - ALPHA

testint(1/(r*sqrt(2*h*r**2-alpha**2-2*k*r**4)),r);


               2        4        2
     SQRT(2*H*R  - 2*K*R  - ALPHA )
INT(--------------------------------,R)
            3        5          2
       2*H*R  - 2*K*R  - R*ALPHA

testint(1/(r*sqrt(2*h*r**2-alpha**2-epsilon**2-2*k*r**4)),r);


               2        4        2          2
     SQRT(2*H*R  - 2*K*R  - ALPHA  - EPSILON )
INT(-------------------------------------------,R)
           3        5          2            2
      2*H*R  - 2*K*R  - R*ALPHA  - R*EPSILON



Comment many of these integrals used to require Steve Harrington's
        code to evaluate. They originated in Novosibirsk as examples
        of using Analytik. There are still a few examples that could
        be evaluated using better heuristics;


testint(a*sin(3*x+5)**2*cos(3*x+5),x);


             3
 SIN(3*X + 5) *A
-----------------
        9

testint(log(x**2)/x**3,x);


          2
  - (LOG(X ) + 1)
------------------
          2
       2*X

testint(x*sin(x+a),x);


SIN(A + X) - COS(A + X)*X

testint((log(x)*(1-x)-1)/(e**x*log(x)**2),x);


     X
-----------
  X
 E *LOG(X)

testint(x**3*(a*x**2+b)**(-1),x);


           2             2
  - LOG(A*X  + B)*B + A*X
---------------------------
              2
           2*A

testint(x**(1/2)*(x+1)**(-7/2),x);


 2*SQRT(X)*SQRT(X + 1)*X*(2*X + 5)
-----------------------------------
          3      2
     15*(X  + 3*X  + 3*X + 1)

testint(x**(-1)*(x+1)**(-1),x);


 - LOG(X + 1) + LOG(X)

testint(x**(-1/2)*(2*x-1)**(-1),x);


     SQRT(X)
INT(----------,X)
        2
     2*X  - X

testint((x**2+1)*x**(1/2),x);


                 2
 2*SQRT(X)*X*(3*X  + 7)
------------------------
           21

testint(x**(-1)*(x-a)**(1/3),x);


                                 1/3
            1/3        ( - A + X)
3*( - A + X)    + INT(---------------,X)*A
                                2
                         A*X - X

testint(x*sinh(x),x);


COSH(X)*X - SINH(X)

testint(x*cosh(x),x);


 - COSH(X) + SINH(X)*X

testint(sinh(2*x)/cosh(2*x),x);


 LOG(COSH(2*X))
----------------
       2

testint((i*eps*sinh x-1)/(eps*i*cosh x+i*a-x),x);


LOG(COSH(X)*I*EPS + A*I - X)

testint(sin(2*x+3)*cos(x)**2,x);


                         2
( - 4*SIN(2*X + 3)*SIN(X) *X + 2*SIN(2*X + 3)*X

            2
  + 2*SIN(X) *COS(2*X + 3) - 4*SIN(X)*COS(2*X + 3)*COS(X)*X

  - 3*COS(2*X + 3) + 3)/8

testint(x*atan(x),x);


          2
 ATAN(X)*X  + ATAN(X) - X
--------------------------
            2

testint(x*acot(x),x);


          2
 ACOT(X)*X  + ACOT(X) + X
--------------------------
            2

testint(x*log(x**2+a),x);


          2               2   2    2
 LOG(A + X )*A + LOG(A + X )*X  - X
-------------------------------------
                  2

testint(sin(x+a)*cos(x),x);


 SIN(A + X)*COS(X)*X - SIN(X)*COS(A + X)*X - COS(A + X)*COS(X)
---------------------------------------------------------------
                               2

testint(cos(x+a)*sin(x),x);


  - SIN(A + X)*COS(X)*X + SIN(X)*COS(A + X)*X - COS(A + X)*COS(X)
------------------------------------------------------------------
                                2

testint((1+sin(x))**(1/2),x);


INT(SQRT(SIN(X) + 1),X)

testint((1-sin(x))**(1/2),x);


INT(SQRT( - SIN(X) + 1),X)

testint((1+cos(x))**(1/2),x);


INT(SQRT(COS(X) + 1),X)

testint((1-cos(x))**(1/2),x);


INT(SQRT( - COS(X) + 1),X)

testint(1/(x**(1/2)-(x-1)**(1/2)),x);


 2*(SQRT(X - 1)*X - SQRT(X - 1) + SQRT(X)*X)
---------------------------------------------
                      3

testint(1/(1-(x+1)**(1/2)),x);


                        SQRT(X + 1)
 - 2*SQRT(X + 1) - INT(-------------,X) - LOG(X)
                           2
                          X  + X

testint(x/(x**4+36)**(1/2),x);


           4
     SQRT(X  + 36)*X
INT(-----------------,X)
          4
         X  + 36

testint(1/(x**(1/3)+x**(1/2)),x);


           1
INT(----------------,X)
      1/3
     X    + SQRT(X)

testint(log(2+3*x**2),x);


                   3*X                2
 2*SQRT(6)*ATAN(---------) + 3*LOG(3*X  + 2)*X - 6*X
                 SQRT(6)
-----------------------------------------------------
                          3

testint(cot(x),x);


            X  2                 X
 - LOG(TAN(---)  + 1) + LOG(TAN(---))
            2                    2

testint(cot x**4,x);


          3
  - COT(X)  + 3*COT(X) + 3*X
-----------------------------
              3

testint(tanh(x),x);


     2*X
LOG(E    + 1) - X

testint(coth(x),x);


     X             X
LOG(E  - 1) + LOG(E  + 1) - X

testint(b**x,x);


    X
   B
--------
 LOG(B)

testint((x**4+x**(-4)+2)**(1/2),x);


  4
 X  - 3
--------
  3*X

testint((2*x+1)/(3*x+2),x);


  - LOG(3*X + 2) + 6*X
-----------------------
           9

testint(x*log(x+(x**2+1)**(1/2)),x);


              2
INT(LOG(SQRT(X  + 1) + X)*X,X)

testint(x*(e**x*sin(x)+1)**2,x);


    2*X       2        2*X                    2*X
(2*E   *SIN(X) *X - 2*E   *SIN(X)*COS(X)*X + E   *SIN(X)*COS(X)

     2*X      2*X      X               X               X
  + E   *X - E    + 8*E *SIN(X)*X - 8*E *COS(X)*X + 8*E *COS(X)

       2
  + 4*X )/8

testint(x*e**x*cos(x),x);


  X
 E *(SIN(X)*X - SIN(X) + COS(X)*X)
-----------------------------------
                 2


Comment the following set came from Herbert Stoyan;


testint(1/(x-3)**4,x);


            - 1
---------------------------
     3      2
 3*(X  - 9*X  + 27*X - 27)

testint(x/(x**3-1),x);


                 2*X + 1          2
 2*SQRT(3)*ATAN(---------) - LOG(X  + X + 1) + 2*LOG(X - 1)
                 SQRT(3)
------------------------------------------------------------
                             6

testint(x/(x**4-1),x);


         2
  - LOG(X  + 1) + LOG(X - 1) + LOG(X + 1)
------------------------------------------
                    4

testint(log(x)*(x**3+1)/(x**4+2),x);


            LOG(X)               LOG(X)             2
  - 4*INT(----------,X) + 2*INT(--------,X) + LOG(X)
            5                     4
           X  + 2*X              X  + 2
------------------------------------------------------
                          2

testint(log(x)+log(x+1)+log(x+2),x);


LOG(X + 2)*X + 2*LOG(X + 2) + LOG(X + 1)*X + LOG(X + 1) + LOG(X)*X

 - 3*X

testint(1/(x**3+5),x);


                            1/3
  1/3                      5    - 2*X           2/3    1/3      2
(5   *( - 2*SQRT(3)*ATAN(--------------) - LOG(5    - 5   *X + X )
                                   1/3
                          SQRT(3)*5

                 1/3
        + 2*LOG(5    + X)))/30

testint(1/sqrt(1+x**2),x);


           2
     SQRT(X  + 1)
INT(--------------,X)
         2
        X  + 1

testint(sqrt(x**2+3),x);


                               2
       2                 SQRT(X  + 3)
 SQRT(X  + 3)*X + 3*INT(--------------,X)
                             2
                            X  + 3
------------------------------------------
                    2

testint(x/(x+1)**2,x);


 LOG(X + 1)*X + LOG(X + 1) - X
-------------------------------
             X + 1


COMMENT The following integrals were used among others as a test of
        Moses' SIN program;


testint(asin x,x);


INT(ASIN(X),X)

testint(x**2*asin x,x);


             2
INT(ASIN(X)*X ,X)

testint(sec x**2/(1+sec x**2-3*tan x),x);


                        X                                X
LOG( - SQRT(5) + 2*TAN(---) + 1) - LOG( - SQRT(2) + TAN(---) + 1)
                        2                                2

                        X                             X
 + LOG(SQRT(5) + 2*TAN(---) + 1) - LOG(SQRT(2) + TAN(---) + 1)
                        2                             2

testint(1/sec x**2,x);


 SIN(X)*COS(X) + X
-------------------
         2

testint((5*x**2-3*x-2)/(x**2*(x-2)),x);


 3*LOG(X - 2)*X + 2*LOG(X)*X - 1
---------------------------------
                X

testint(1/(4*x**2+9)**(1/2),x);


             2
     SQRT(4*X  + 9)
INT(----------------,X)
           2
        4*X  + 9

testint((x**2+4)**(-1/2),x);


           2
     SQRT(X  + 4)
INT(--------------,X)
         2
        X  + 4

testint(1/(9*x**2-12*x+10),x);


               3*X - 2
 SQRT(6)*ATAN(---------)
               SQRT(6)
-------------------------
           18

testint(1/(x**8-2*x**7+2*x**6-2*x**5+x**4),x);


        2       4          2       3                  4
(3*LOG(X  + 1)*X  - 3*LOG(X  + 1)*X  - 30*LOG(X - 1)*X

                   3              4              3       4       2
  + 30*LOG(X - 1)*X  + 24*LOG(X)*X  - 24*LOG(X)*X  - 30*X  + 12*X

                  3
  + 8*X + 4)/(12*X *(X - 1))

testint((a*x**3+b*x**2+c*x+d)/((x+1)*x*(x-3)),x);


(27*LOG(X - 3)*A + 9*LOG(X - 3)*B + 3*LOG(X - 3)*C + LOG(X - 3)*D

  - 3*LOG(X + 1)*A + 3*LOG(X + 1)*B - 3*LOG(X + 1)*C + 3*LOG(X + 1)*D

  - 4*LOG(X)*D + 12*A*X)/12

testint(1/(2-log(x**2+1))**5,x);


               2     5           2     4           2     3
 - INT(1/(LOG(X  + 1)  - 10*LOG(X  + 1)  + 40*LOG(X  + 1)

                     2     2           2
           - 80*LOG(X  + 1)  + 80*LOG(X  + 1) - 32),X)


% The next integral appeared in Risch's 1968 paper.

testint(2*x*e**(x**2)*log(x)+e**(x**2)/x+(log(x)-2)/(log(x)**2+x)**2+
    ((2/x)*log(x)+(1/x)+1)/(log(x)**2+x),x);


   2             2
  X        3    X                       2            2
(E  *LOG(X)  + E  *LOG(X)*X + LOG(LOG(X)  + X)*LOG(X)

              2                         2
  + LOG(LOG(X)  + X)*X - LOG(X))/(LOG(X)  + X)


% The following integral would not evaluate in REDUCE 3.3.

testint(exp(x*ze+x/2)*sin(pi*ze)**4*x**4,ze);


  (2*X*ZE + X)/2  3            4  4               4  2   2
(E              *X *(SIN(PI*ZE) *X  + 4*SIN(PI*ZE) *X *PI

                   3             3
     - 4*SIN(PI*ZE) *COS(PI*ZE)*X *PI

                    3                3                2  2   2
     - 16*SIN(PI*ZE) *COS(PI*ZE)*X*PI  + 12*SIN(PI*ZE) *X *PI

                                    3        4     4       2   2
     - 24*SIN(PI*ZE)*COS(PI*ZE)*X*PI  + 24*PI ))/(X  + 20*X *PI

           4
    + 64*PI )


% This one evaluates:

testint(erf(x),x);


   2
  X
 E  *ERF(X)*X*PI + SQRT(PI)
----------------------------
             2
            X
           E  *PI


% So why not this one?

testint(erf(x+a),x);


INT(ERF(A + X),X)


Comment here is an example of using the integrator with pattern
        matching;


for all m,n let int(k1**m*log(k1)**n/(p**2-k1**2),k1)=foo(m,n),
                int(k1*log(k1)**n/(p**2-k1**2),k1)=foo(1,n),
                int(k1**m*log(k1)/(p**2-k1**2),k1)=foo(m,1),
                int(k1*log(k1)/(p**2-k1**2),k1)=foo(1,1),
                int(log(k1)**n/(k1*(p**2-k1**2)),k1)=foo(-1,n);



int(k1**2*log(k1)/(p**2-k1**2),k1);


*** FOO declared operator 

FOO(2,1)


COMMENT It is interesting to see how much of this one can be done;


let f1s= (12*log(s/mc**2)*s**2*pi**2*mc**3*(-8*s-12*mc**2+3*mc)
        + pi**2*(12*s**4*mc+3*s**4+176*s**3*mc**3-24*s**3*mc**2
        -144*s**2*mc**5-48*s*mc**7+24*s*mc**6+4*mc**9-3*mc**8))
         /(384*e**(s/y)*s**2);



int(f1s,s);


   2            S/Y           1              3   3
(PI *( - 36864*E   *INT(--------------,S)*S*Y *MC
                              S/Y
                         384*E   *S*Y

                S/Y           1              2   5
       - 55296*E   *INT(--------------,S)*S*Y *MC
                              S/Y
                         384*E   *S*Y

                S/Y           1              2   4
       + 13824*E   *INT(--------------,S)*S*Y *MC
                              S/Y
                         384*E   *S*Y

                S/Y           1                 7
       - 18432*E   *INT(--------------,S)*S*Y*MC
                              S/Y
                         384*E   *S*Y

               S/Y           1                 6
       + 9216*E   *INT(--------------,S)*S*Y*MC
                             S/Y
                        384*E   *S*Y

               S/Y           1               9
       - 1536*E   *INT(--------------,S)*S*MC
                             S/Y
                        384*E   *S*Y

               S/Y           1               8
       + 1152*E   *INT(--------------,S)*S*MC
                             S/Y
                        384*E   *S*Y

                  S     2     3            S       2   3
       + 96*LOG(-----)*S *Y*MC  + 96*LOG(-----)*S*Y *MC
                   2                        2
                 MC                       MC

                   S          5            S          4       3
       + 144*LOG(-----)*S*Y*MC  - 36*LOG(-----)*S*Y*MC  - 12*S *Y*MC
                    2                       2
                  MC                      MC

            3         2  2         2  2        2     3       2     2
       - 3*S *Y - 24*S *Y *MC - 6*S *Y  - 176*S *Y*MC  + 24*S *Y*MC

               3           3         2   3         2   2
       - 24*S*Y *MC - 6*S*Y  - 80*S*Y *MC  + 24*S*Y *MC

                   5       9       8         S/Y
       + 144*S*Y*MC  - 4*MC  + 3*MC ))/(384*E   *S)


factor int;



ws;


      S/Y           1               2   3         3        2   2
(384*E   *INT(--------------,S)*S*PI *MC *( - 96*Y  - 144*Y *MC
                    S/Y
               384*E   *S*Y

           2             4          3       6       5      2
     + 36*Y *MC - 48*Y*MC  + 24*Y*MC  - 4*MC  + 3*MC ) + PI *(

             S     2     3            S       2   3
    96*LOG(-----)*S *Y*MC  + 96*LOG(-----)*S*Y *MC
              2                        2
            MC                       MC

                 S          5            S          4       3
     + 144*LOG(-----)*S*Y*MC  - 36*LOG(-----)*S*Y*MC  - 12*S *Y*MC
                  2                       2
                MC                      MC

          3         2  2         2  2        2     3       2     2
     - 3*S *Y - 24*S *Y *MC - 6*S *Y  - 176*S *Y*MC  + 24*S *Y*MC

             3           3         2   3         2   2             5
     - 24*S*Y *MC - 6*S*Y  - 80*S*Y *MC  + 24*S*Y *MC  + 144*S*Y*MC

           9       8         S/Y
     - 4*MC  + 3*MC ))/(384*E   *S)


Comment the following integrals reveal deficiencies in the current
integrator;


%high degree denominator;
%testint(1/(2-log(x**2+1))**5,x);

%this example should evaluate;
testint(sin(2*x)/cos(x),x);


     SIN(2*X)
INT(----------,X)
      COS(X)


%this example, which appeared in Tobey's thesis, needs factorization
%over algebraic fields. It currently gives an ugly answer and so has
%been suppressed;

% testint((7*x**13+10*x**8+4*x**7-7*x**6-4*x**3-4*x**2+3*x+3)/
%         (x**14-2*x**8-2*x**7-2*x**4-4*x**3-x**2+2*x+1),x);

symbolic summarize!-integral!-test();

                *****     SUMMARY OF INTEGRAL TESTS     *****

Number of integrals tested: 272

Total time taken: 175865 ms

Number of garbage collections: 168

Number of incorrect integrals: 0

Number of unevaluated integrals: 59

Integrands of unevaluated integrals are:


   1
--------
 LOG(X)


     1
------------
 LOG(X + 1)


     1
------------
       2  2
 LOG(X) *X


LOG(LOG(LOG(LOG(X))))


      P
SIN(X)


 SIN(X)
--------
   X


 COS(X)
--------
   X


 SIN(X)
--------
    2
   X


       2
 SIN(X)
---------
    X


      4  3
TAN(X) *X


      6  3
TAN(X) *X


        XI
 COS(--------)*COS(X)*X
      SIN(X)
------------------------
              2
        SIN(X)


  A*X
 E
------
  X


  X
 A
----
  2
 X


        X
       A *X
-------------------
  2  2
 B *X  + 2*B*X + 1


  2
 X
E


    X
   E
  E
 E
E


 X
E *LOG(X)


 X
E *LOG(X)*X


    LOG(X)
---------------
 SQRT(A*X + B)


SQRT(C + D*X)*SQRT(A + B*X)


 SQRT(A + B*X)
---------------
       X


 SQRT(A + B*X)
---------------
       2
      X


        1
-----------------
 SQRT(A + B*X)*X


        1
------------------
                2
 SQRT(A + B*X)*X


      1
--------------
       2
 SQRT(X  - 1)


SQRT(X)*SQRT(X + 1)


       2                 2
 SQRT(X  - 4) + 10*SQRT(X  - 1)
--------------------------------
         2            2
   SQRT(X  - 1)*SQRT(X  - 4)


            2    2
 SQRT(SQRT(A  + X ) + X)
-------------------------
            X


       2
 SQRT(X  + 1)
--------------
     2
    X  + 1


            3           3
  - 3*SQRT(X  + 1) + 3*X  + 3
------------------------------
             4
          2*X  + 2*X


           1
-----------------------
           2        2
 SQRT(2*H*R  - ALPHA )


                 1
------------------------------------
           2        2          2
 SQRT(2*H*R  - ALPHA  - EPSILON )*R


                1
---------------------------------
           2                2
 SQRT(2*H*R  - 2*K*R - ALPHA )*R


                     1
--------------------------------------------
           2                2          2
 SQRT(2*H*R  - 2*K*R - ALPHA  - EPSILON )*R


               R
--------------------------------
           2        4        2
 SQRT(2*E*R  - 2*K*R  - ALPHA )


               R
-------------------------------
           2                2
 SQRT(2*E*R  - 2*K*R - ALPHA )


                1
----------------------------------
           2        4        2
 SQRT(2*H*R  - 2*K*R  - ALPHA )*R


                      1
---------------------------------------------
           2        4        2          2
 SQRT(2*H*R  - 2*K*R  - ALPHA  - EPSILON )*R


           1
-----------------------
 2*SQRT(X)*X - SQRT(X)


           1/3
 ( - A + X)
---------------
       X


SQRT(SIN(X) + 1)


SQRT( - SIN(X) + 1)


SQRT(COS(X) + 1)


SQRT( - COS(X) + 1)


       - 1
-----------------
 SQRT(X + 1) - 1


       X
---------------
       4
 SQRT(X  + 36)


       1
----------------
  1/3
 X    + SQRT(X)


          2
LOG(SQRT(X  + 1) + X)*X


         3
 LOG(X)*X  + LOG(X)
--------------------
        4
       X  + 2


      1
--------------
       2
 SQRT(X  + 1)


      2
SQRT(X  + 3)


ASIN(X)


         2
ASIN(X)*X


       1
----------------
         2
 SQRT(4*X  + 9)


      1
--------------
       2
 SQRT(X  + 4)


             2     5           2     4           2     3
( - 1)/(LOG(X  + 1)  - 10*LOG(X  + 1)  + 40*LOG(X  + 1)

                   2     2           2
         - 80*LOG(X  + 1)  + 80*LOG(X  + 1) - 32)


ERF(A + X)


 SIN(2*X)
----------
  COS(X)



end;

4: 4: 
Quitting
Sat Jun 29 13:44:51 PDT 1991
