# Using R as a Computer Algebra System with Ryacas

**Econometrics and Free Software**, and kindly contributed to R-bloggers]. (You can report issue about the content on this page here)

Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.

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 their blog:

**Econometrics and Free Software**.

R-bloggers.com offers

**daily e-mail updates**about R news and tutorials about learning R and many other topics. Click here if you're looking to post or find an R/data-science job.

Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.