# integrals.frink

``` // This file contains transformation rules suitable for finding // integrals of expressions. // // At the moment, this is just a proof of concept.  Further development // will probably use the very nice set of rules derived by Albert D. Rich // for computer-based evaluation of integrals: // // http://www.apmaths.uwo.ca/~arich/index.html // // It appears possible to use his machine-readable rules written for // Mathematica and transform them automatically into Frink (some mathematical // functions will of course need to be added.) // // Perhaps a better method will involve Risch integration which is very // complex to implement but provides a decision procedure which can decide // if an expression *can* be integrated. // transformations integrals {    // Multiple integrals    // Bail-out condition for first integral    Integrate[_n, _x, 1] <-> Integrate[_n, _x]    // Otherwise take one integral and decrement.    Integrate[_n, _x, _times is isInteger] <-> Integrate[Integrate[_n,_x], _x, _times-1]        // Integrate both sides of an equation.    Integrate[_a === _b, _x]   <->  Integrate[_a, _x] === Integrate[_b, _x]        // Expression entirely free of x    Integrate[_a, _x] :: freeOf[_a, _x] <-> _a _x    // Separate out multiplicative parts that are free of x    Integrate[_a _b, _x] :: freeOf[_a, _x] and expressionContains[_b, _x] <-> _a Integrate[_b, _x]    // Chain rules for sums    Integrate[_a + _b, _x]  <->  Integrate[_a, _x] + Integrate[_b, _x]    // Powers of x    Integrate[_x^(_y:1), _x] :: _y != -1 <-> _x^(_y+1)/(_y+1)    // Special case of 1/x  (also written as x^-1)    Integrate[_x^-1, _x] <-> ln[_x]    // b^(a x)    Integrate[_b^((_a:1) _x), _x] :: freeOf[_b,_x] and freeOf[_a, _x] <-> _b^(_a _x) / (_a ln[_b])    // ln[x]    Integrate[ln[_x], _x]  <->  _x ln[_x] - _x    // Trigonometric functions    Integrate[sin[(_a:1) _x], _x] :: freeOf[_a,_x]  <-> -1/_a cos[_a _x]    Integrate[cos[(_a:1) _x], _x] :: freeOf[_a,_x]  <->  1/_a sin[_a _x]    Integrate[tan[(_a:1) _x], _x] :: freeOf[_a,_x]  <->  -1/_a ln[cos[_a _x]]    Integrate[sec[(_a:1) _x]^2, _x]     :: freeOf[_a,_x]  <-> 1/_a tan[_a _x]    Integrate[(1/cos[(_a:1) _x])^2, _x] :: freeOf[_a,_x]  <-> 1/_a tan[_a _x]    Integrate[sin[_x] / (1-sin[_x]^2), _x] :: freeOf[_a,_x]  <-> sec[_x]    Integrate[sin[_a _x] / (1-sin[_a _x]^2), _x] :: freeOf[_a,_x]  <-> sec[_a _x]    // Definite integral.    // This is inefficient because it has to integrate the same expression twice.    // We need a way to define a variable and use that twice.  And the    // substituteExpression is awkward, as it's not evaluated until an eval is    // called on the expression..  We need an operator form that is    // replaced at transformation time.    Integrate[_n, _x, _fromX, _toX] <-> substituteExpression[Integrate[_n, _x], _x, _toX] - substituteExpression[Integrate[_n, _x], _x, _fromX]    // Multiple definite integral    // Otherwise take one integral and decrement.    Integrate[_n, _x, _times is isInteger, _fromX, _toX] <-> substituteExpression[Integrate[_n, _x, _times], _x, _toX] - substituteExpression[Integrate[_n, _x, _times], _x, _fromX]    /* Integration by parts.    "When you apply integration by parts, there is    usually a choice of what to call u and what to call dv. The "LIATE"    heuristic provides a suggestion of how to do that. It doesn't always work,    but it works so often that it is worth remembering and using it as the    first attempt.    LIATE stands for:    Logarithmic    Inverse trigonometric    Algebraic    Trigonometric    Exponential    The heuristic says: when there are two factors in the integrand, choose u    as the one furthest to the left in LIATE and choose dv as the one furthest    to the right.    https://en.wikipedia.org/wiki/Integration_by_parts#LIATE_rule    TODO:  Complete this.    */    //   Integrate[_u, _x]  } ```

This is a program written in the programming language Frink.
For more information, view the Frink Documentation or see More Sample Frink Programs.

Alan Eliasen was born 18664 days, 9 hours, 18 minutes ago.