## File: simplify.chapt.txt

package info (click to toggle)
yacas 1.3.6-2
 `123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226` `````` Simplification of expressions *INTRO Simplification of expression is a big and non-trivial subject. Simplification implies that there is a preferred form. In practice the preferred form depends on the calculation at hand. This chapter describes the functions offered that allow simplification of expressions. *CMD Simplify --- try to simplify an expression *STD *CALL Simplify(expr) *PARMS {expr} -- expression to simplify *DESC This function tries to simplify the expression {expr} as much as possible. It does this by grouping powers within terms, and then grouping similar terms. *E.G. 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; *SEE TrigSimpCombine, RadSimp *CMD RadSimp --- simplify expression with nested radicals *STD *CALL RadSimp(expr) *PARMS {expr} -- an expression containing nested radicals *DESC This function tries to write the expression "expr" as a sum of roots of integers: \$Sqrt(e1) + Sqrt(e2) + ...\$, where \$e1\$, \$e2\$ and so on are natural numbers. The expression "expr" may not contain free variables. It does this by trying all possible combinations for \$e1\$, \$e2\$, ... 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 {expr}. The last example underneath illustrates this problem. Furthermore, if the numerical value of {expr} is large, the number of possibilities becomes exorbitantly big so the evaluation may take very long. *E.G. 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; *SEE Simplify, N *CMD FactorialSimplify --- Simplify hypergeometric expressions containing factorials *STD *CALL FactorialSimplify(expression) *PARMS {expression} -- expression to simplify *DESC {FactorialSimplify} takes an expression that may contain factorials, and tries to simplify it. An expression like \$ (n+1)! / n! \$ would simplify to \$(n+1)\$. The following steps are taken to simplify: * 1. binomials are expanded into factorials * 2. the expression is flattened as much as possible, to reduce it to a sum of simple rational terms * 3. expressions like \$ p^n/p^m \$ are reduced to \$p^(n-m)\$ if \$n-m\$ is an integer * 4. expressions like \$ 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. *EG 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 *SEE Simplify, !, Bin *CMD LnExpand --- expand a logarithmic expression using standard logarithm rules *STD *CALL LnExpand(expr) *PARMS {expr} -- the logarithm of an expression *DESC {LnExpand} takes an expression of the form \$Ln(expr)\$, and applies logarithm rules to expand this into multiple {Ln} expressions where possible. An expression like \$Ln(a*b^n)\$ would be expanded to \$Ln(a)+n*Ln(b)\$. If the logarithm of an integer is discovered, it is factorised using {Factors} and expanded as though {LnExpand} had been given the factorised form. So \$Ln(18)\$ goes to \$Ln(x)+2*Ln(3)\$. *EG 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) *SEE Ln, LnCombine, Factors *CMD LnCombine --- combine logarithmic expressions using standard logarithm rules *STD *CALL LnCombine(expr) *PARMS {expr} -- an expression possibly containing multiple {Ln} terms to be combined *DESC {LnCombine} finds {Ln} terms in the expression it is given, and combines them using logarithm rules. It is intended to be the exact converse of {LnExpand}. *EG 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) *SEE Ln, LnExpand *CMD TrigSimpCombine --- combine products of trigonometric functions *STD *CALL TrigSimpCombine(expr) *PARMS {expr} -- expression to simplify *DESC This function applies the product rules of trigonometry, e.g. \$Cos(u)*Sin(v) = (1/2)*(Sin(v-u) + Sin(v+u))\$. As a result, all products of the trigonometric functions {Cos} and {Sin} disappear. The function also tries to simplify the resulting expression as much as possible by combining all similar terms. This function is used in for instance {Integrate}, to bring down the expression into a simpler form that hopefully can be integrated easily. *E.G. 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 *SEE Simplify, Integrate, Expand, Sin, Cos, Tan ``````