Integration can be performed by the function Integrate(), which has two calling conventions:

Integrate(variable) expression
Integrate(variable, from, to) expression

Integrate() can have its own set of rules for specific integrals, which might return a correct answer immediately. Alternatively, it calls the function AntiDeriv(), to see if the anti-derivative can be determined for the integral requested. If this is the case, the anti-derivative is used to compose the output.

If the integration algorithm cannot perform the integral, the expression is returned unsimplified.

The integration algorithm

General structure

The integration starts at the function Integrate(), but the task is delegated to other functions, one after the other. Each function can deem the integral unsolvable, and thus return the integral unevaluated. These different functions offer hooks for adding new types of integrals to be handled.

Expression clean-up

Integration starts by first cleaning up the expression, by calling TrigSimpCombine() to simplify expressions containing multiplications of trigonometric functions into additions of trigonometric functions (for which the integration rules are trivial), and then passing the result to Simplify().

Generalized integration rules

For the function AntiDeriv(), which is responsible for finding the anti-derivative of a function, the code splits up expressions according to the additive properties of integration, eg. integration of \(a+b\) is the same as integrating \(a\) and \(b\) separately and adding the integrals.

  • Polynomials which can be expressed as univariate polynomials in the variable to be integrated over are handled by one integration rule.

  • Expressions of the form \(pf(x)\), where \(p\) represents a univariate polynomial, and \(f(x)\) an integrable function, are handled by a special integration rule. This transformation rule has to be designed carefully not to invoke infinite recursion.

  • Rational functions, \(f(x)/g(x)\) with both \(f(x)\) and \(g(x)\) being univariate polynomials, is handled separately also, using partial fraction expansion to reduce rational function to a sum of simpler expressions.

Integration tables

For elementary functions, yacas uses integration tables. For instance, the fact that the anti-derivative of \(\cos(x)\) is \(\sin(x)\) is declared in an integration table.

For the purpose of setting up the integration table, a few declaration functions have been defined, which use some generalized pattern matchers to be more flexible in recognizing expressions that are integrable.

Integrating simple functions of a variable

For functions like \(\sin(x)\) the anti-derivative can be declared with the function IntFunc().

The calling sequence for IntFunc() is:


For instance, for the function Cos() there is a declaration:


The fact that the second argument is a pattern means that each occurrence of the variable to be matched should be referred to as _x, as in the example above.

IntFunc() generalizes the integration implicitly, in that it will set up the system to actually recognize expressions of the form \(\cos(ax+b)\), and return \(\sin(ax+b)/a\) automatically. This means that the variables a and b are reserved, and can not be used in the pattern. Also, the variable used (in this case, _x is actually matched to the expression passed in to the function, and the variable var is the real variable being integrated over. To clarify: suppose the user wants to integrate \(\cos(cy+d)\) over \(y\), then the following variables are set:

  • a = \(c\)

  • b = \(d\)

  • x = \(ay+b\)

  • var = \(x\)

When functions are multiplied by constants, that situation is handled by the integration rule that can deal with univariate polynomials multiplied by functions, as a constant is a polynomial of degree zero.

Integrating functions containing expressions of the form \(ax^2+b\)

There are numerous expressions containing sub-expressions of the form \(ax^2+b\) which can easily be integrated.

The general form for declaring anti-derivatives for such expressions is:

IntPureSquare(variable, pattern, sign2, sign0, antiderivative)

Here IntPureSquare() uses MatchPureSquared() to match the expression.

The expression is searched for the pattern, where the variable can match to a sub-expression of the form \(ax^2+b\), and for which both \(a\) and \(b\) are numbers and \(a*sign2>0\) and \(b*sign0>0\).

As an example:


declares that the anti-derivative of \(\frac{c}{a*x^2+b}\) is


if both \(a\) and \(b\) are positive numbers.