Simplify | try to simplify an expression |

RadSimp | simplify expression with nested radicals |

FactorialSimplify | Simplify hypergeometric expressions containing factorials |

LnExpand | expand a logarithmic expression using standard logarithm rules |

LnCombine | combine logarithmic expressions using standard logarithm rules |

TrigSimpCombine | combine products of trigonometric functions |

Simplify -- try to simplify an expression

Simplify(expr) |

In> a*b*a^2/b-a^3 Out> (b*a^3)/b-a^3; In> Simplify(a*b*a^2/b-a^3) Out> 0; |

RadSimp -- simplify expression with nested radicals

RadSimp(expr) |

It does this by trying all possible combinations for $e_{1}$, $e_{2}$, ...
Every possibility is numerically evaluated using ** N** and compared with the numerical evaluation of
"expr". If the approximations are equal (up to a certain margin),
this possibility is returned. Otherwise, the expression is returned
unevaluated.

Note that due to the use of numerical approximations, there is a small
chance that the expression returned by ** RadSimp** is
close but not equal to

In> RadSimp(Sqrt(9+4*Sqrt(2))) Out> Sqrt(8)+1; In> RadSimp(Sqrt(5+2*Sqrt(6)) \ +Sqrt(5-2*Sqrt(6))) Out> Sqrt(12); In> RadSimp(Sqrt(14+3*Sqrt(3+2 *Sqrt(5-12*Sqrt(3-2*Sqrt(2)))))) Out> Sqrt(2)+3; |

But this command may yield incorrect results:

In> RadSimp(Sqrt(1+10^(-6))) Out> 1; |

FactorialSimplify -- Simplify hypergeometric expressions containing factorials

FactorialSimplify(expression) |

The following steps are taken to simplify:

- binomials are expanded into factorials
- the expression is flattened as much as possible, to reduce it to a sum of simple rational terms
- expressions like $\frac{p ^{n}}{p ^{m}} $ are reduced to $p ^{n - m}$ if $n - m$ is an integer
- expressions like $\frac{n!}{m!} $ are simplified if $n - m$ is an integer

The function ** Simplify** is used to determine if the relevant expressions $n - m$
are integers.

In> FactorialSimplify( (n-k+1)! / (n-k)! ) Out> n+1-k In> FactorialSimplify(n! / Bin(n,k)) Out> k! *(n-k)! In> FactorialSimplify(2^(n+1)/2^n) Out> 2 |

LnExpand -- expand a logarithmic expression using standard logarithm rules

LnExpand(expr) |

If the logarithm of an integer is discovered, it is factorised using ** Factors**
and expanded as though

In> LnExpand(Ln(a*b^n)) Out> Ln(a)+Ln(b)*n In> LnExpand(Ln(a^m/b^n)) Out> Ln(a)*m-Ln(b)*n In> LnExpand(Ln(60)) Out> 2*Ln(2)+Ln(3)+Ln(5) In> LnExpand(Ln(60/25)) Out> 2*Ln(2)+Ln(3)-Ln(5) |

LnCombine -- combine logarithmic expressions using standard logarithm rules

LnCombine(expr) |

In> LnCombine(Ln(a)+Ln(b)*n) Out> Ln(a*b^n) In> LnCombine(2*Ln(2)+Ln(3)-Ln(5)) Out> Ln(12/5) |

TrigSimpCombine -- combine products of trigonometric functions

TrigSimpCombine(expr) |

This function is used in for instance ** Integrate**,
to bring down the expression into a simpler form that hopefully can be
integrated easily.

In> PrettyPrinter'Set("PrettyForm"); True In> TrigSimpCombine(Cos(a)^2+Sin(a)^2) 1 In> TrigSimpCombine(Cos(a)^2-Sin(a)^2) Cos( -2 * a ) Out> In> TrigSimpCombine(Cos(a)^2*Sin(b)) Sin( b ) Sin( -2 * a + b ) -------- + ----------------- 2 4 Sin( -2 * a - b ) - ----------------- 4 |