**Econometrics and Free Software**, and kindly contributed to R-bloggers)

R is used to perform statistical analysis and doesn't focus on symbolic maths. But it is sometimes useful to let the computer derive a function for you (and have the analytic expression of said derivative), but maybe you don't want to leave your comfy R shell. It is possible to turn R into a full-fledged computer algebra system. CASs are tools that perform symbolic operations, such as getting the expression of the derivative of a user-defined (and thus completely arbitrary) function. Popular CASs include the proprietary Mathematica and Maple. There exists a lot of CASs under a Free Software license, Maxima (based on the very old Macsyma), Yacas, Xcas… In this post I will focus on Yacas and the `Ryacas`

libarary. There is also the possibility to use the `rSympy`

library that uses the `Sympy`

Python library, which has a lot more features than Yacas. However, depending on your operating system installation can be tricky as it also requires `rJava`

as a dependency.

Even though `Ryacas`

is quite nice to have, there are some issues though. For example, let's say you want the first derivative of a certain function f. If you use `Ryacas`

to get it, the returned object won't be a function. There is a way to “extract” the text from the returned object and make a function out of it. But there are still other issues; I'll discuss them later.

## Installation

Installation should be rather painless. On Linux you need to install Yacas first, which should be available in the major distros' repositories. Then you can install `Ryacas`

from within the R shell. On Windows, you need to run these three commands (don't bother installing Yacas first):

```
install.packages('Ryacas')
library(Ryacas)
yacasInstall()
```

You can find more information on the project's page.

## Example session

First, you must load `Ryacas`

and define symbols that you will use in your functions.

```
require("Ryacas")
```

```
## Loading required package: Ryacas Loading required package: XML
```

```
x <- Sym("x")
```

You can then define your fonctions:

```
my_func <- function(x) {
return(x/(x^2 + 3))
}
```

And you can get the derivative for instance:

```
my_deriv <- yacas(deriv(my_func(x), x))
```

```
## [1] "Starting Yacas!"
```

If you check the class of `my_deriv`

, you'll see that it is of class `yacas`

, which is not very useful. Let's «convert» it to a function:

```
my_deriv2 <- function(x) {
eval(parse(text = my_deriv$YacasForm))
}
```

We can then evaluate it. A lot of different operations are possible. But there are some problems.

## Issues with Ryacas

You can't use elements of a vector as parameters of your function, i.e.:

```
theta <- Sym("theta")
func <- function(x) {
return(theta[1] * x + theta[2])
}
# Let's integrate this
Func <- yacas(Integrate(func(x), x))
```

returns `(x^2*theta)/2+NA*x;`

which is not quite what we want…there is a workaround however. Define your functions like this:

```
a <- Sym("a")
b <- Sym("b")
func2 <- function(x) {
return(a * x + b)
}
# Let's integrate this
Func2 <- yacas(Integrate(func2(x), x))
```

we get the expected result: `(x^2*a)/2+b*x;`

. Now replace `a`

and `b`

by the thetas:

```
Func2 <- gsub("a", "theta[1]", Func2$YacasForm)
Func2 <- gsub("b", "theta[2]", Func2)
```

Now we have what we want:

```
Func2
```

```
## [1] "(x^2*theta[1])/2+theta[2]*x;"
```

You can then copy-paste this result into a function.

Another problem is if you use built-in functions that are different between R and Yacas. For example:

```
my_log <- function(x) {
return(sin(log(2 + x)))
}
```

Now try to differentiate it:

```
dmy_log <- yacas(deriv(my_log(x), x))
```

you get: `Cos(Ln(x+2))/(x+2);`

. The problem with this, is that R doesn't recognize `Cos`

as the cosine (which is `cos`

in R) and the same goes for `Ln`

. These are valid Yacas functions, but that is not the case in R. So you'll have to use `gsub`

to replace these functions and then copy paste the end result into a function.

## Conclusion

While it has some flaws, `Ryacas`

can be quite useful if you need to derive or integrate complicated expressions that you then want to use in R. Using some of the tricks I showed here, you should be able to overcome some of its shortcomings. If installation of `rJava`

and thus `rSympy`

becomes easier, I'll probably also do a short blog-post about it, as it has more features than `Ryacas`

.

**leave a comment**for the author, please follow the link and comment on his blog:

**Econometrics and Free Software**.

R-bloggers.com offers

**daily e-mail updates**about R news and tutorials on topics such as: visualization (ggplot2, Boxplots, maps, animation), programming (RStudio, Sweave, LaTeX, SQL, Eclipse, git, hadoop, Web Scraping) statistics (regression, PCA, time series, trading) and more...