1 | initial version |

If you look at the output of

```
integrate(legendre_P(64,x)*sin((1+x)*pi/2),x,-1,1)
```

you'll see that it is a massive expression with large rationals, powers of pi, etc. If `expr`

is any Sage symbolic expression, then `expr.n(bits)`

works by evaluating all the "leaves" of the expression to the given `bits`

of precision, then doing the arithmetic to evaluate the expression. Thus large roundoff and cancellation can and sometimes will occur. Indeed, that is exactly what is happening here. You can get around this by increasing the precision sufficiently. If you want to be *sure* of the result, you can use interval arithmetic. Here's how:

```
sage: a = integrate(legendre_P(64,x)*sin((1+x)*pi/2),x,-1,1)
sage: a.n(prec=300)
51516.6651093...60
sage: a.n(prec=500)
0
sage: a.n(prec=2000)
3.3204630...841332374315143e-97
sage: RealIntervalField(53)( a )
0.?e81
sage: RealIntervalField(200)( a )
0.?e37
sage: RealIntervalField(500)( a )
0.?e-54
sage: RealIntervalField(1000)( a )
3.32046...71175?e-97
```

For example, the lines

```
sage: RealIntervalField(500)( a )
0.?e-54
```

tell you that if evaluate the expression using 500 bits of precision, it's *definitely* 0.000000... (at least 53 zeros). Internally, this is done by evaluating with 500 bits of precision and rounding down and *also* evaluating with 500 bits and rounding up, and tracking the resulting "interval".

Copyright Sage, 2010. Some rights reserved under creative commons license. Content on this site is licensed under a Creative Commons Attribution Share Alike 3.0 license.