1 | initial version |

With the algorithm by Fu et al, implemented as fu.py in Sympy:

```
import sympy as sy
f = sqrt(3)/3*cos(x)+1/3*sin(x)
f_reduced = SR(sy.fu(sy.sympify(f))); f
```

gives `2/3*sin(1/3*pi + x)`

(which is $\frac{\pi}{2}$-close to the answer you expected!).

From my own experience, this type of functionality is *very useful* (1). I'd define this reduction as: "try to get a formula with the smaller number of terms as possible". This is the type of simplification that often looks nicer, or simpler (to a physicist, say), and it what I often want from a CAS -- though in many real cases a trained human does better and faster. A step forward would be that the program introduces new useful auxiliary variables, I ignore if this exists in some form already.

In the case at hand, there is a single specific reduction which works, `sy.FU['TR10i'](expr)`

, while using `sy.fu(expr)`

runs through several reductions and picks the one which gives a "simpler" expression, as explained in the doc.

(1) The use case is solving physics/engineering problems that involve long formulas with many trig functions/complex exponentials. As a concrete example, these often arise when computing determinants in Fourier space.

2 | No.2 Revision |

With the algorithm by Fu et al, implemented as fu.py in Sympy:

```
import sympy as sy
f = sqrt(3)/3*cos(x)+1/3*sin(x)
f_reduced = SR(sy.fu(sy.sympify(f)));
```~~f
~~f_reduced

gives `2/3*sin(1/3*pi + x)`

(which is $\frac{\pi}{2}$-close to the answer you expected!).

From my own experience, this type of functionality is *very useful* (1). I'd define this reduction as: "try to get a formula with the smaller number of terms as possible". This is the type of simplification that often looks nicer, or simpler (to a physicist, say), and it what I often want from a CAS -- though in many real cases a trained human does better and faster. A step forward would be that the program introduces new useful auxiliary variables, I ignore if this exists in some form already.

In the case at hand, there is a single specific reduction which works, `sy.FU['TR10i'](expr)`

, while using `sy.fu(expr)`

runs through several reductions and picks the one which gives a "simpler" expression, as explained in the doc.

(1) The use case is solving physics/engineering problems that involve long formulas with many trig functions/complex exponentials. As a concrete example, these often arise when computing determinants in Fourier space.

3 | No.3 Revision |

With the algorithm by Fu et al, implemented as fu.py in Sympy:

```
import sympy as sy
f = sqrt(3)/3*cos(x)+1/3*sin(x)
f_reduced = SR(sy.fu(sy.sympify(f))); f_reduced
```

gives `2/3*sin(1/3*pi + x)`

(which is $\frac{\pi}{2}$-close to the answer you expected!).

From my own experience, this type of functionality is *very useful* (1). I'd define this reduction as: "try to get a formula with the smaller number of terms as possible". This is the type of simplification that often looks nicer, or simpler (to a physicist, say), and it is what I often want from a CAS -- though in many real cases a trained human does better and faster. A step forward would be that the program introduces new useful auxiliary variables, I ignore if this exists in some form already.

In the case at hand, there is a single specific reduction which works, `sy.FU['TR10i'](expr)`

, while using `sy.fu(expr)`

runs through several reductions and picks the one which gives a "simpler" expression, as explained in the doc.

(1) The use case is solving physics/engineering problems that involve long formulas with many trig functions/complex exponentials. As a concrete example, these often arise when computing determinants in Fourier space.

4 | No.4 Revision |

With the algorithm by Fu et al, implemented as fu.py in Sympy:

```
import sympy as sy
f = sqrt(3)/3*cos(x)+1/3*sin(x)
f_reduced = SR(sy.fu(sy.sympify(f))); f_reduced
```

gives `2/3*sin(1/3*pi + x)`

(which is $\frac{\pi}{2}$-close to the answer you expected!).

From my own experience, this type of functionality is *very useful* (1). I'd define this reduction as: "try to get a formula with the smaller number of terms as possible". This is the type of simplification that often looks nicer, or simpler (to a physicist, say), and it is what I often want from a CAS -- though in many real cases a trained human does better and faster. A step forward would be that the program introduces new useful auxiliary variables, I ignore if this exists in some form already.

`sy.FU['TR10i'](expr)`

, while using `sy.fu(expr)`

runs through several reductions and picks the one which gives a "simpler" expression, as explained in the doc.

~~long ~~formulas with many trig functions/complex exponentials. As a concrete example, these often arise when computing determinants in Fourier space.

5 | No.5 Revision |

With the algorithm by Fu et al, implemented as fu.py in Sympy:

```
import sympy as sy
f = sqrt(3)/3*cos(x)+1/3*sin(x)
f_reduced = SR(sy.fu(sy.sympify(f))); f_reduced
```

gives `2/3*sin(1/3*pi + x)`

(which is $\frac{\pi}{2}$-close to the answer you expected!).

From my own experience, this type of functionality is *very useful* (1). I'd define this reduction as: "try to get a formula with the smaller number of terms as possible". This is the type of simplification that often looks nicer, or simpler (to a physicist, say), and it is what I often want from a CAS -- though in many real cases a trained human does better and faster. A step forward would be that the program introduces new useful auxiliary variables, I ignore if this exists in some form already.

`sy.FU['TR10i'](expr)`

, while using `sy.fu(expr)`

runs through several reductions and picks the one which gives a "simpler" expression, as explained in the doc.

(1) The use case is solving physics/engineering problems that involve formulas with many trig functions/complex exponentials. As a concrete example, ~~these often arise when computing determinants ~~consider a determinant in Fourier ~~space.~~

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.