/usr/share/doc/axiom-doc/hypertex/equdifferentiallinear.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">
   Closed-Form Solutions of Linear Differential Equations
  </div>
  <hr/>
A differential equation is an equation involving an unknown function and
one or more of its derivatives. The equation is called ordinary if 
derivatives with respect to only one dependent variable appear in the
equation (it is called partial otherwise). The package
<a href="db.xhtml?ElementaryFunctionODESolver">ElementaryFunctionODESolver</a>
provides the top-level operation
<a href="dbopsolve.xhtml">solve</a> for finding closed-form solutions of
ordinary differential equations.

To solve a differential equation, you must first create an operator for the
unknown function. We let y be the unknown function in terms of x.
<ul>
 <li>
  <input type="submit" id="p1" class="subbut" 
    onclick="makeRequest('p1');"
    value="y:=operator 'y" />
  <div id="ansp1"><div></div></div>
 </li>
</ul>
You then type the equation using <a href="dbopd.xhtml">D</a> to create the
derivatives of the unknown function y(x) where x is any symbol you choose
(the so-called dependent variable). This is how you enter the equation
<pre>
    y'' + y' + y = 0
</pre>
<ul>
 <li>
  <input type="submit" id="p2" class="subbut" 
    onclick="handleFree(['p1','p2']);"
    value="deq:=D(y x,x,2)+D(y x,x)+y x=0" />
  <div id="ansp2"><div></div></div>
 </li>
</ul>
The simplest way to invoke the <a href="dbopsolve.xhtml">solve</a> command
is with three arguments, 
<ul>
 <li>the differential equation</li>
 <li>the operator representing the unknown function</li>
 <li>the dependent variable</li>
</ul>
So, to solve the above equation, we enter this.
<ul>
 <li>
  <input type="submit" id="p3" class="subbut" 
    onclick="handleFree(['p1','p2','p3']);"
    value="solve(deq,y,x)" />
  <div id="ansp3"><div></div></div>
 </li>
</ul>
Since linear ordinary differential equations have infinitely many solutions,
<a href="dbopsolve.xhtml">solve</a> returns a particular solution f_p and
a basis f1,..fn for the solutions of the corresponding homogeneous equation.
Any expression of the form fp+c1 f1+...+cn fn where the ci do not involve the
dependent variable is also a solution. This is similar to what you get when
you solve systems of linear algebraic equations.

A way to select a unique solution is to specify initial conditions: choose a
value a for the dependent variable and specify the values of the unknown
function and its derivatives at a. If the number of initial conditions is
equal to the order of the equation, then the solution is unique (if it exists
in closed form) and <a href="dbopsolve.xhtml">solve</a> tries to find it. To
specify initial conditions to <a href="dbopsolve.xhtml">solve</a>, use an
<a href="db.xhtml?Equation">Equation</a> of the form x=a for the third
parameter instead of the dependent variable, and add a fourth parameter
consisting of the list of values y(a), y'(a), ...

To find the solution of y''+y=0 satisfying y(0)=y'(0)=1, do this.
<ul>
 <li>
  <input type="submit" id="p4" class="subbut" 
    onclick="handleFree(['p1','p4']);"
    value="deq:=D(y x,x,2)+y x" />
  <div id="ansp4"><div></div></div>
 </li>
</ul>
You can omit the "=0" when you enter the equation to be solved.
<ul>
 <li>
  <input type="submit" id="p5" class="subbut" 
    onclick="handleFree(['p1','p4','p5']);"
    value="solve(deq,y,x=0,[1,1])" />
  <div id="ansp5"><div></div></div>
 </li>
</ul>
Axiom is not limited to linear differential equations with constant
coefficients. It can also find solutions when the coefficients are
rational or algebraic functions of the dependent variable. Furthermore,
Axiom is not limited by the order of the equation. Axiom can solve the
following thrid order equations with polynomial coefficients.
<ul>
 <li>
  <input type="submit" id="p6" class="subbut" 
    onclick="handleFree(['p1','p6']);"
    value="deq:=x^3*D(y x,x,3)+x^2*D(y x,x,2)-2*x*D(y x,x)+2*yx=2*x^4" />
  <div id="ansp6"><div></div></div>
 </li>
 <li>
  <input type="submit" id="p7" class="subbut" 
    onclick="handleFree(['p1','p6','p7']);"
    value="solve(deq,y,x)" />
  <div id="ansp7"><div></div></div>
 </li>
</ul>
On the other hand, and in contrast with the operation
<a href="dbopintegrate.xhtml">integrate</a> it can happen that Axiom finds
no solution and that some closed-form solution still exists. While it is
mathematically complicated to describe exactly when the solutions are
guaranteed to be found, the following statements are correct and form
good guidelines for linear ordinary differential equations.
<ul>
 <li>If the coefficients are constants, Axiom finds a complete basis of
     solutions (i.e. all solutions).
 </li>
 <li>If the coefficients are rational functions in the dependent variable,
     Axiom ast least finds all solutions that do not involve algebraic
     functions.
 </li>
</ul>
Note that this last statement does not mean that Axiom does not find the
solutions that are algebraic functions. It means that it is not guaranteed
that the algebraic function solutions will be found. This is an example
where all the algebraic solutions are found.
<ul>
 <li>
  <input type="submit" id="p8" class="subbut" 
    onclick="handleFree(['p1','p8']);"
    value="deq:=(x^2+1)*D(y x,x,2)+3*x*D(y x,x)+y x=0" />
  <div id="ansp8"><div></div></div>
 </li>
 <li>
  <input type="submit" id="p9" class="subbut" 
    onclick="handleFree(['p1','p8','p9']);"
    value="solve(deq,y,x)" />
  <div id="ansp9"><div></div></div>
 </li>
</ul>

 </body>
</html>
axiom-hypertex-data 20120501-8 / usr / share / doc / axiom-doc / hypertex / equdifferentiallinear.xhtml
