This type of behavior is rather common, and is NOT a bug. It simply shows the differences between symbolic calculations, without careful consideration of the problem, and numeric calculations.

Let's consider the two results separately. First,

evalf( int( ln(2+2*cos(t)^2+cos(t)^4), t = 0 .. Pi));
                        -8.710344354 + 19.73920881 I

The int command produces an exact expression for the antiderivative:

F := int( ln(2+2*cos(t)^2+cos(t)^4), t);
                                          /
                                          |
4 I ln(2) ln(exp(I t)) - I ln(exp(I t)) ln|
                                          |
                                          \

               4                2                6                 8\
  54 (exp(I t))  + 12 (exp(I t))  + 12 (exp(I t))  + 1 + (exp(I t)) |
  ------------------------------------------------------------------|
                                       4                            |
                             (exp(I t))                             /

                             /                     -----                      
                             |                      \                         
                     2       |                       )                        
   - 2 I ln(exp(I t))  + 8 I |                      /                         
                             |                     -----                      
                             |            /     4        2        6         8\
                             \_R1 = RootOf\54 _Z  + 12 _Z  + 12 _Z  + 1 + _Z /

                                                               \
                                                               |
  /1                /_R1 - exp(I t)\   1      /_R1 - exp(I t)\\|
  |- ln(exp(I t)) ln|--------------| + - dilog|--------------|||
  \8                \     _R1      /   8      \     _R1      //|
                                                               |
                                                               /

This is not a very useful result. But, if we continue, evaluating this antiderivative at each endpoint and subtracting gives:

F1 := simplify(eval( F, t=Pi ));
F2 := simplify(eval( F, t=0  ));
                       /Sum(/       /_R1 + 1\        /_R1 + 1\\,             /
                       |    |I Pi ln|-------| + dilog|-------||  _R1 = RootOf\
                 2     |    \       \  _R1  /        \  _R1  //               
Pi ln(5) + 2 I Pi  + I |                                                      
                       |                                                      
                       |                                                      
                       \                                                      

       4        2        6         8\ .. )\
  54 _Z  + 12 _Z  + 12 _Z  + 1 + _Z /     |
                                          |
                                          |
                                          |
                                          |
                                          /
       /                     -----                                    \
       |                      \                                       |
       |                       )                             /_R1 - 1\|
     I |                      /                         dilog|-------||
       |                     -----                           \  _R1  /|
       |            /     4        2        6         8\              |
       \_R1 = RootOf\54 _Z  + 12 _Z  + 12 _Z  + 1 + _Z /              /
evalf( F1-F2 );
                        -8.710344359 + 19.73920881 I

The complex valued result is not expected. It is obtained because we have not give careful consideration to the branch cuts of the antiderivative.

On the other hand, the second option:

evalf( Int( ln(2+2*cos(t)^2+cos(t)^4), t = 0 .. Pi));
                                 3.658972529

does not try to do any symbolic evaluation, it immediately resorts to a numerical integration routine. Here, the integrand is always positive, so the real-valued and positive result is consistent with our expectations.

It is cases like this that make the distincition between int and Int important. With evalf( int( ) ), Maple will first attempt a symbolic evaluation of the definite integral. If this is not successful, then it will use numerical quadrature. But, if you want to avoid the time spent trying to find an antiderivative (or, worse, finding a useless antiderivative as in this example) use evalf( Int( ) ).

Doug

---------------------------------------------------------------------
Douglas B. Meade  <><
Math, USC, Columbia, SC 29208  E-mail: mailto:meade@math.sc.edu       
Phone:  (803) 777-6183         URL:    http://www.math.sc.edu/~meade/

From the Wikipedia: "A software bug (or just "bug") is an error, flaw, mistake, failure, or fault in a computer program that prevents it from behaving as intended (e.g., producing an incorrect result)." When Maple produces an incorrect result, it's a bug. 

As JacquesC says, the error arises because Maple is applying the Fundamental Theorem of Calculus incorrectly. The function that the Int command produces is not an antiderivative of our function on the entire interval [0, Pi] because it is discontinuous on the interval. Therefore, the FTC doesn't apply.

Just because Maple has been making this error for as long as we can all remember, doesn't excuse it. To tell the user not to blindly use the definite integral function is good advice since Maple refuses to acknowledge that there is a problem. To suggest that the user is at fault for not properly considering the branch cuts lays the bug on the wrong doorstep. How hard would it be for Maple to check that the answer from the definite integral is (essentially) the same as the numerical result? It's far better to give no result than an incorrect one. Or at least a warning.

I have no problem with the indefinite integral because Maple makes it clear for the beginning that the it will not bother with the constants of integration.

I guess most of my frustration arises from trying to convince students that learning Maple is worth the effort . And then every term Maple undercuts me by making an elementary error like this.

(Alex: I used the online version and got nothing, but thx for the result!)

I have no reason to doubt Jacques' answer ... but played a bit more,
may be the following may help (but does not solve the problem).

Problems already occure for Int(1/(cos(t)-(-1-I)^(1/2))*t*sin(t),t = 0 .. Pi)
or -Int(cos(t)*t*sin(t)/(-cos(t)-(1+I)^(1/2)),t = 0 .. Pi).

Within Int( ln(2+2*cos(t)^2+cos(t)^4), t = 0 .. Pi) we have a (trigonometric)
polynomial of degree 4, which splits over the Reals:

  r1,r2:=(-1+I)^(1/2), -(-1-I)^(1/2);
  p1,p2:= 'eval((x-r)*(x-conjugate(r)), r= r1)', 'eval((x-r)*(x-conjugate(r)), r= r2)';
  'p1*p2': '%'=evalc(collect(expand(%),x));

                                   1/2           1/2
                 r1, r2 := (-1 + I)   , -(-1 - I)


                              _ |                     _ |
       p1, p2 := (x - r) (x - r)|      , (x - r) (x - r)|
                                |r = r1                 |r = r2


                                     4      2
                        p1 p2 = 2 + x  + 2 x


The parabolas p have real coefficients and no roots on the interval, so log
turns the product to a sum, thus we have 2 integrals of the following form:

  Int(ln((cos(t)-conjugate(r))*(cos(t)-r)),t=0..Pi);
  ``=PDEtools[dchange](t=arccos(x),%,[x]);
  ``=value(rhs(%)): # <------- in terms of hypergeometrics
  ``=simplify(rhs(%),size);
  
  J:=rhs(%):

                   Pi
                  /
                 |                 _
                 |    ln((cos(t) - r) (cos(t) - r)) dt
                 |
                /
                  0


                          1
                         /                  _
                        |   ln((x - r) (x - r))
                     =  |   ------------------- dx
                        |             2 1/2
                       /        (1 - x )
                         -1


         /                           /     1  \1/2
         |                           |1 - ----|
         |                           |      2 |
         |             _             \     r  /
    = Pi |ln(-r) + ln(-r) + ln(1/2 + -------------)
         |                                 2
         \

                                      \
                                      |
                                      |
                        /     1  \1/2 |
         + ln(1/2 + 1/2 |1 - ----|   )|
                        |     _2 |    |
                        \     r  /    /


Hence the value is given by

  'eval(J,r=r1) + eval(J,r=r2)';
  ``=evalc(%):
  combine(%,ln);
  evalf(%);

                         J|       + J|
                          |r = r1    |r = r2


                     1/2          1/2 1/2   1/2          1/2 1/2
              13   10      (3 + 10   )    10      (3 + 10   )
      = Pi ln(-- + ----- + -------------------- + --------------)
              16     4              8                   4


                             = 3.658972529


Numerical cross check:

  Int( ln(2+2*cos(t)^2+cos(t)^4), t = 0 .. Pi); evalf(%);

                    Pi
                   /
                  |                   2         4
                  |    ln(2 + 2 cos(t)  + cos(t) ) dt
                  |
                 /
                   0


                             3.658972529


I was using Maple 11.02 with Digits:=14