/usr/share/doc/axiom-doc/hypertex/calintegrals.xhtml

<?xml version="1.0" encoding="UTF-8"?>
<html xmlns="http://www.w3.org/1999/xhtml" 
      xmlns:xlink="http://www.w3.org/1999/xlink"
      xmlns:m="http://www.w3.org/1998/Math/MathML">
 <head>
  <meta http-equiv="Content-Type" content="text/html" charset="us-ascii"/>
  <title>Axiom Documentation</title>
  <style>

   html {
     background-color: #ECEA81;
   }

   body { 
     margin: 0px;
     padding: 0px;
   }

   div.command { 
     color:red;
   }

   div.center {
     color:blue;
   }

   div.reset {
     visibility:hidden;
   }

   div.mathml { 
     color:blue;
   }

   input.subbut {
     background-color:#ECEA81;
     border: 0;
     color:green;
     font-family: "Courier New", Courier, monospace;
   }

   input.noresult {
     background-color:#ECEA81;
     border: 0;
     color:black;
     font-family: "Courier New", Courier, monospace;
   }

   span.cmd { 
     color:green;
     font-family: "Courier New", Courier, monospace;
   }

   pre {
     font-family: "Courier New", Courier, monospace;
   }
  </style>
  <script type="text/javascript">
<![CDATA[
     // This is a hash table of the values we've evaluated.
     // This is indexed by a string argument. 
     // A value of 0 means we need to evaluate the expression
     // A value of 1 means we have evaluated the expression
   Evaled = new Array();
     // this says we should modify the page
   hiding = 'show';
     // and this is the id of the div tag to modify (defaulted)
   thediv = 'mathAns';
     // commandline will mark that its arg has been evaled so we don't repeat
   function commandline(arg) {
     Evaled[arg] = 0;  // remember that we have set this value
     thediv='ans'+arg; // mark where we should put the output
     var ans = document.getElementById(arg).value;
     return(ans);
   }
   // the function only modifies the page if when we're showing the
   // final result, otherwise it does nothing.
   function showanswer(mathString,indiv) {
     if (hiding == 'show') { // only do something useful if we're showing
       indiv = thediv;  // override the argument so we can change it
       var mystr = mathString.split("</div>");
       for (var i=0; i < mystr.length; i++) {
         if (mystr[i].indexOf("mathml") > 0) {
           var mymathstr = mystr[i].concat("</div>");
         }
       }
       // this turns the string into a dom fragment
       var mathRange = document.createRange();
       var mathBox=
               document.createElementNS('http://www.w3.org/1999/xhtml','div');
       mathRange.selectNodeContents(mathBox);
       var mymath = mathRange.createContextualFragment(mymathstr);
       mathBox.appendChild(mymath);
       // now we need to format it properly
       // and we stick the result into the requested div block as a child.
       var mathAns = document.getElementById(indiv);
       mathAns.removeChild(mathAns.firstChild);
       mathAns.appendChild(mathBox);
     }
   }
   // this function takes a list of expressions ids to evaluate
   // the list contains a list of "free" expression ids that need to
   // be evaluated before the last expression. 
   // For each expression id, if it has not yet been evaluated we
   // evaluate it "hidden" otherwise we can skip the expression.
   // Once we have evaluated all of the free expressions we can
   // evaluate the final expression and modify the page.
   function handleFree(arg) {
     var placename = arg.pop();      // last array val is real
     var mycnt = arg.length;         // remaining free vars
       // we handle all of the prerequired expressions quietly
     hiding = 'hide';
     for (var i=0; i<mycnt; i++) {   // for each of the free variables
       if (Evaled[arg[i]] == null) { // if we haven't evaled it
         Evaled[arg[i]] = 0;         // remember we evaled it
         makeRequest(arg[i]);        // initialize the free values
       }
     }
       // and now we start talking to the page again
     hiding = 'show';                // we want to show this
     thediv = 'ans'+placename;       // at this div id
     makeRequest(placename);         // and we eval and show it
   }
]]>
<![CDATA[
  function ignoreResponse() {}
  function resetvars() {
    http_request = new XMLHttpRequest();         
    http_request.open('POST', '127.0.0.1:8085', true);
    http_request.onreadystatechange = ignoreResponse;
    http_request.setRequestHeader('Content-Type', 'text/plain');
    http_request.send("command=)clear all");
    return(false);
  }
]]>
 function init() {
 }
 function makeRequest(arg) {
   http_request = new XMLHttpRequest();         
   var command = commandline(arg);
   //alert(command);
   http_request.open('POST', '127.0.0.1:8085', true);
   http_request.onreadystatechange = handleResponse;
   http_request.setRequestHeader('Content-Type', 'text/plain');
   http_request.send("command="+command);
   return(false);
 }
 function lispcall(arg) {
   http_request = new XMLHttpRequest();         
   var command = commandline(arg);
   //alert(command);
   http_request.open('POST', '127.0.0.1:8085', true);
   http_request.onreadystatechange = handleResponse;
   http_request.setRequestHeader('Content-Type', 'text/plain');
   http_request.send("lispcall="+command);
   return(false);
 }
 function showcall(arg) {
   http_request = new XMLHttpRequest();         
   var command = commandline(arg);
   //alert(command);
   http_request.open('POST', '127.0.0.1:8085', true);
   http_request.onreadystatechange = handleResponse;
   http_request.setRequestHeader('Content-Type', 'text/plain');
   http_request.send("showcall="+command);
   return(false);
 }
 function interpcall(arg) {
   http_request = new XMLHttpRequest();         
   var command = commandline(arg);
   //alert(command);
   http_request.open('POST', '127.0.0.1:8085', true);
   http_request.onreadystatechange = handleResponse;
   http_request.setRequestHeader('Content-Type', 'text/plain');
   http_request.send("interpcall="+command);
   return(false);
 }
 function handleResponse() {
  if (http_request.readyState == 4) {
   if (http_request.status == 200) {
    showanswer(http_request.responseText,'mathAns');
   } else
   {
     alert('There was a problem with the request.'+ http_request.statusText);
   }
  }
 }

  </script>
 </head>
 <body onload="resetvars();">
  <div align="center"><img align="middle" src="doctitle.png"/></div>
  <hr/>
  <div align="center">Integration</div>
  <hr/>
Axiom has extensive library facilities for integration.

The first example is the integration of a fraction with a denominator that
factors into a quadratic and a quartic irreducible polynomial. The usual
partial fraction approach used by most other computer algebra systems either
fails or introduces expensive unneeded algebraic numbers.

We use a factorization-free algorithm.
<ul>
 <li>
  <input type="submit" id="p1" class="subbut" 
    onclick="makeRequest('p1');"
    value="integrate((x^2+2*x+1)/((x+1)^6+1),x)" />
  <div id="ansp1"><div></div></div>
 </li>
</ul>
When real parameters are present, the form of the integral can depend on the
signs of some expressions.

Rather than query the user or make sign assumptions, Axiom returns all
possible answers.
<ul>
 <li>
  <input type="submit" id="p2" class="subbut" 
    onclick="makeRequest('p2');"
    value="integrate(1/(x^2+a),x)" />
  <div id="ansp2"><div></div></div>
 </li>
</ul>
The <a href="dbopintegrate.xhtml">integrate</a> operation generally assumes
that all parameters are real. The only exception is when the integrand has
complex valued quantities.

If the parameter is complex instead of real, then the notion of sign is
undefined and there is a unique answer. You can request this answer by
"prepending" the word "complex" to the command name.
<ul>
 <li>
  <input type="submit" id="p3" class="subbut" 
    onclick="makeRequest('p3');"
    value="complexIntegrate(1/(x^2+a),x)" />
  <div id="ansp3"><div></div></div>
 </li>
</ul>
The following two examples illustrate the limitations of table-based
approaches. The two integrands are very similar, but the answer to one of
them requires the addition of two new algebraic numbers.

This is the easy one. The next one looks very similar but the answer is
much more complicated.
<ul>
 <li>
  <input type="submit" id="p4" class="subbut" 
    onclick="makeRequest('p4');"
    value="integrate(x^3/(a+b*x)^(1/3),x)" />
  <div id="ansp4"><div></div></div>
 </li>
</ul>
Only an algorithmic approach is guaranteed to find what new constants must
be added in order to find a solution.
<ul>
 <li>
  <input type="submit" id="p5" class="subbut" 
    onclick="makeRequest('p5');"
    value="integrate(1/(x^3*(a+b*x)^(1/3)),x)" />
  <div id="ansp5"><div></div></div>
 </li>
</ul>
Some computer algebra systems use heuristics or table-driven approaches to
integration. When these systems cannot determine the answer to an
integration problem, they reply "I don't know". Axiom uses an algorithm
for integration that conclusively proves that an integral cannot be expressed
in terms of elementary functions.

When Axiom returns an integral sign, it has proved that no answer exists as
an elementary function.
<ul>
 <li>
  <input type="submit" id="p6" class="subbut" 
    onclick="makeRequest('p6');"
    value="integrate(log(1+sqrt(a*x+b))/x,x)" />
  <div id="ansp6"><div></div></div>
 </li>
</ul>
Axiom can handle complicated mixed functions much beyond what you can find
in tables. Whenever possible, Axiom tries to express the answer using the
functions present in the integrand.
<ul>
 <li>
  <input type="submit" id="p7" class="subbut" 
    onclick="makeRequest('p7');"
    value="integrate((sinh(1+sqrt(x+b))+2*sqrt(x+b))/(sqrt(x+b)*(x+cosh(1+sqrt(x+b)))),x)" />
  <div id="ansp7"><div></div></div>
 </li>
</ul>
A strong structure-checking algorithm in Axiom finds hidden algebraic 
relationships between functions.
<ul>
 <li>
  <input type="submit" id="p8" class="subbut" 
    onclick="makeRequest('p8');"
    value="integrate(tan(atan(x)/3),x)" />
  <div id="ansp8"><div></div></div>
 </li>
</ul>
The discovery of this algebraic relationship is necessary for correct
integration of this function. Here are the details:
<ol>
 <li>
  If x=tan(t) and g=tan(t/3) then the following algebraic relationship is true:
<pre>
      g^3 - 3xg^2 - 3g + x = 0    
</pre>
 </li>
 <li>
  Integrate g using this algebraic relation; this produces:
<pre>
((24g^2-8)log(3g^2-1) + (81x^2+24)g^2 + 72xg - 27x^2 - 16) / (54g^2 - 18)
</pre>
 </li>
 <li>
  Rationalize the denominator, producing:
<pre>
     (8log(3g^2-1) - 3g^2 + 18xg + 16)/18
</pre>
  Replace g by the initial definition g=tan(arctan(x)/3) to produce the
final result.
 </li>
</ol>
This is an example of a mixed function where the algebraic layer is over
the transcendental one.
<ul>
 <li>
  <input type="submit" id="p9" class="subbut" 
    onclick="makeRequest('p9');"
    value="integrate((x+1)/(x*(x+log x)^(3/2)),x)" />
  <div id="ansp9"><div></div></div>
 </li>
</ul>
While incomplete for non-elementary functions, Axiom can handle some of them.
<ul>
 <li>
  <input type="submit" id="p10" class="subbut" 
    onclick="makeRequest('p10');"
    value="integrate(exp(-x^2)*erf(x)/(erf(x)^3-erf(x)^2-erf(x)+1),x)" />
  <div id="ansp10"><div></div></div>
 </li>
</ul>
More examples of Axiom's integration capabilities are discussed in
<a href="axbook/section-8.8.xhtml">Integration</a>.
 </body>
</html>
axiom-hypertex-data 20120501-8 / usr / share / doc / axiom-doc / hypertex / calintegrals.xhtml
