# TranscendentalManipulations(R, F)ΒΆ

TranscendentalManipulations provides functions to simplify and expand expressions involving transcendental operators.

cos2sec: F -> F

`cos2sec(f)` converts every `cos(u)` appearing in `f` into `1/sec(u)`.

cosh2sech: F -> F

`cosh2sech(f)` converts every `cosh(u)` appearing in `f` into `1/sech(u)`.

cot2tan: F -> F

`cot2tan(f)` converts every `cot(u)` appearing in `f` into `1/tan(u)`.

cot2trig: F -> F

`cot2trig(f)` converts every `cot(u)` appearing in `f` into `cos(u)/sin(u)`.

coth2tanh: F -> F

`coth2tanh(f)` converts every `coth(u)` appearing in `f` into `1/tanh(u)`.

coth2trigh: F -> F

`coth2trigh(f)` converts every `coth(u)` appearing in `f` into `cosh(u)/sinh(u)`.

csc2sin: F -> F

`csc2sin(f)` converts every `csc(u)` appearing in `f` into `1/sin(u)`.

csch2sinh: F -> F

`csch2sinh(f)` converts every `csch(u)` appearing in `f` into `1/sinh(u)`.

expand: F -> F

`expand(f)` performs the following expansions on `f:` begin{items} item 1. logs of products are expanded into sums of logs. item 2. trigonometric and hyperbolic trigonometric functions of sums are expanded into sums of products of trigonometric and hyperbolic trigonometric functions. item 3. formal powers of the form `(a/b)^c` are expanded into `a^c * b^(-c)`. end{items}

expandLog: F -> F

`expandLog(f)` converts every `log(a/b)` appearing in `f` into `log(a) - log(b)`, and every `log(a*b)` into `log(a) + log(b)`.

expandPower: F -> F

`expandPower(f)` converts every power `(a/b)^c` appearing in `f` into `a^c * b^(-c)`.

expandTrigProducts: F -> F if F has ConvertibleTo Pattern R and R has PatternMatchable R and R has ConvertibleTo Pattern R and F has PatternMatchable R

`expandTrigProducts(e)` replaces `sin(x)*sin(y)` by `(cos(x-y)-cos(x+y))/2`, `cos(x)*cos(y)` by `(cos(x-y)+cos(x+y))/2`, and `sin(x)*cos(y)` by `(sin(x-y)+sin(x+y))/2`. Note: this operation uses pattern matcher, so it is relatively expensive. To avoid getting into an infinite loop the transformations are applied at most ten times.

htrigs: F -> F

`htrigs(f)` converts all the exponentials in `f` into hyperbolic sines and cosines.

removeCoshSq: F -> F

`removeCoshSq(f)` converts every `cosh(u)^2` appearing in `f` into `1 - sinh(u)^2`, and also reduces higher powers of `cosh(u)` with that formula.

removeCosSq: F -> F

`removeCosSq(f)` converts every `cos(u)^2` appearing in `f` into `1 - sin(u)^2`, and also reduces higher powers of `cos(u)` with that formula.

removeSinhSq: F -> F

`removeSinhSq(f)` converts every `sinh(u)^2` appearing in `f` into `1 - cosh(u)^2`, and also reduces higher powers of `sinh(u)` with that formula.

removeSinSq: F -> F

`removeSinSq(f)` converts every `sin(u)^2` appearing in `f` into `1 - cos(u)^2`, and also reduces higher powers of `sin(u)` with that formula.

sec2cos: F -> F

`sec2cos(f)` converts every `sec(u)` appearing in `f` into `1/cos(u)`.

sech2cosh: F -> F

`sech2cosh(f)` converts every `sech(u)` appearing in `f` into `1/cosh(u)`.

simplify: F -> F

`simplify(f)` performs the following simplifications on `f:` begin{items} item 1. rewrites trigs and hyperbolic trigs in terms of `sin` , `cos`, `sinh`, `cosh`. item 2. rewrites `sin^2` and `sinh^2` in terms of `cos` and `cosh`, item 3. rewrites `exp(a)*exp(b)` as `exp(a+b)`. item 4. rewrites `(a^(1/n))^m * (a^(1/s))^t` as a single power of a single radical of `a`. end{items}

simplifyExp: F -> F

`simplifyExp(f)` performs the following simplifications on `f:` begin{items} item 1. rewrites `exp(a)*exp(b)` as `exp(a+b)`. item 2. rewrites `a^b*a^c` as `a^(b+c)`. item 3. rewrites `exp(a)/exp(b)` as `exp(a-b)`. item 4. rewrites `a^b/a^c` as `a^(b-c)`. end{items}

simplifyLog: F -> F

`simplifyLog(f)` converts every `log(a) - log(b)` appearing in `f` into `log(a/b)`, every `log(a) + log(b)` into `log(a*b)` and every `n*log(a)` into `log(a^n)`.

sin2csc: F -> F

`sin2csc(f)` converts every `sin(u)` appearing in `f` into `1/csc(u)`.

sinh2csch: F -> F

`sinh2csch(f)` converts every `sinh(u)` appearing in `f` into `1/csch(u)`.

tan2cot: F -> F

`tan2cot(f)` converts every `tan(u)` appearing in `f` into `1/cot(u)`.

tan2trig: F -> F

`tan2trig(f)` converts every `tan(u)` appearing in `f` into `sin(u)/cos(u)`.

tanh2coth: F -> F

`tanh2coth(f)` converts every `tanh(u)` appearing in `f` into `1/coth(u)`.

tanh2trigh: F -> F

`tanh2trigh(f)` converts every `tanh(u)` appearing in `f` into `sinh(u)/cosh(u)`.