CubicFormula (p)
	    Compute roots of a cubic (degree 3) polynomial using the
	    cubic formula.  The polynomial should be given as a
	    vector of coefficients.  That is
	    4*x^3 + 2*x + 1 corresponds to the vector
            [1,2,0,4].
	    Returns a column vector of the three solutions.  The first solution is always
	    the real one as a cubic always has one real solution.
	  
See Planetmath, Mathworld, or Wikipedia for more information.
EulersMethod (f,x0,y0,x1,n)
	    Use classical Euler's method to numerically solve y'=f(x,y) for
	    initial x0, y0 going to
	    x1 with n increments,
	    returns y at x1.
	    Unless you explicitly want to use Euler's method, you should really
	    think about using
	    RungeKutta
	    for solving ODE.
	  
	    Systems can be solved by just having y be a
	    (column) vector everywhere.  That is, y0 can
	    be a vector in which case f should take a number
	    x and a vector of the same size for the second
	    argument and should return a vector of the same size.
	  
EulersMethodFull (f,x0,y0,x1,n)
	    Use classical Euler's method to numerically solve y'=f(x,y) for
	    initial x0, y0 going to
	    x1 with n increments,
	    returns an n+1 by 2 matrix with the
	    x and y values.
	    Unless you explicitly want to use Euler's method, you should really
	    think about using
	    RungeKuttaFull
	    for solving ODE.
	    Suitable
	    for plugging into 
	    LinePlotDrawLine or
	    LinePlotDrawPoints.
	  
Example:
genius>LinePlotClear();genius>line = EulersMethodFull(`(x,y)=y,0,1.0,3.0,50);genius>LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");
	    Systems can be solved by just having y be a
	    (column) vector everywhere.  That is, y0 can
	    be a vector in which case f should take a number
	    x and a vector of the same size for the second
	    argument and should return a vector of the same size.
	  
The output for a system is still a n by 2 matrix with the second entry being a vector. If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with ExpandMatrix, and pick out the right columns. Example:
genius>LinePlotClear();genius>lines = EulersMethodFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,500);genius>lines = ExpandMatrix(lines);genius>firstline = lines@(,[1,2]);genius>secondline = lines@(,[1,3]);genius>LinePlotWindow = [0,10,-2,2];genius>LinePlotDrawLine(firstline,"color","blue","legend","First");genius>LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");
See Mathworld or Wikipedia for more information.
Version 1.0.10 onwards.
FindRootBisection (f,a,b,TOL,N)
Find root of a function using the bisection method.
		  a and b are the initial guess interval,
		  f(a) and f(b) should have opposite signs.
	    TOL is the desired tolerance and
N is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector [success,value,iteration], where success is a boolean indicating success, value is the last value computed, and iteration is the number of iterations done.
FindRootFalsePosition (f,a,b,TOL,N)
Find root of a function using the method of false position.
		  a and b are the initial guess interval,
		  f(a) and f(b) should have opposite signs.
	    TOL is the desired tolerance and
N is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector [success,value,iteration], where success is a boolean indicating success, value is the last value computed, and iteration is the number of iterations done.
FindRootMullersMethod (f,x0,x1,x2,TOL,N)
Find root of a function using the Muller's method.
	    TOL is the desired tolerance and
N is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector [success,value,iteration], where success is a boolean indicating success, value is the last value computed, and iteration is the number of iterations done.
FindRootSecant (f,a,b,TOL,N)
Find root of a function using the secant method.
		  a and b are the initial guess interval,
		  f(a) and f(b) should have opposite signs.
	    TOL is the desired tolerance and
N is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector [success,value,iteration], where success is a boolean indicating success, value is the last value computed, and iteration is the number of iterations done.
HalleysMethod (f,df,ddf,guess,epsilon,maxn)
Find zeros using Halley's method.  f is
		  the function, df is the derivative of
		  f, and ddf is the second derivative of
		  f.  guess is the initial
		  guess.  The function returns after two successive values are
		  within epsilon of each other, or after maxn tries, in which case the function returns null indicating failure.
	  
	  See also NewtonsMethod and SymbolicDerivative.
  	  
Example to find the square root of 10:
genius>HalleysMethod(`(x)=x^2-10,`(x)=2*x,`(x)=2,3,10^-10,100)
See Wikipedia for more information.
Version 1.0.18 onwards.
NewtonsMethod (f,df,guess,epsilon,maxn)
Find zeros using Newton's method.  f is
		  the function and df is the derivative of
		  f.  guess is the initial
		  guess.  The function returns after two successive values are
		  within epsilon of each other, or after maxn tries, in which case the function returns null indicating failure.
	  
	  See also NewtonsMethodPoly and SymbolicDerivative.
  	  
Example to find the square root of 10:
genius>NewtonsMethod(`(x)=x^2-10,`(x)=2*x,3,10^-10,100)
See Wikipedia for more information.
Version 1.0.18 onwards.
PolynomialRoots (p)
	    Compute roots of a polynomial (degrees 1 through 4)
	    using one of the formulas for such polynomials.
	    The polynomial should be given as a
	    vector of coefficients.  That is
	    4*x^3 + 2*x + 1 corresponds to the vector
            [1,2,0,4].
	    Returns a column vector of the solutions.
	  
The function calls QuadraticFormula, CubicFormula, and QuarticFormula.
QuadraticFormula (p)
	    Compute roots of a quadratic (degree 2) polynomial using the
	    quadratic formula.  The polynomial should be given as a
	    vector of coefficients.  That is
	    3*x^2 + 2*x + 1 corresponds to the vector
            [1,2,3].
	    Returns a column vector of the two solutions.
	  
See Planetmath, or Mathworld, or Wikipedia for more information.
QuarticFormula (p)
	    Compute roots of a quartic (degree 4) polynomial using the
	    quartic formula.  The polynomial should be given as a
	    vector of coefficients.  That is
	    5*x^4 + 2*x + 1 corresponds to the vector
            [1,2,0,0,5].
	    Returns a column vector of the four solutions.
	  
See Planetmath, Mathworld, or Wikipedia for more information.
RungeKutta (f,x0,y0,x1,n)
	    Use classical non-adaptive fourth order Runge-Kutta method to
	    numerically solve
	    y'=f(x,y) for initial x0, y0
	    going to x1 with n
	    increments, returns y at x1.
	  
	    Systems can be solved by just having y be a
	    (column) vector everywhere.  That is, y0 can
	    be a vector in which case f should take a number
	    x and a vector of the same size for the second
	    argument and should return a vector of the same size.
	  
RungeKuttaFull (f,x0,y0,x1,n)
	    Use classical non-adaptive fourth order Runge-Kutta method to
	    numerically solve
	    y'=f(x,y) for initial x0, y0
	    going to x1 with n
	    increments,
	    returns an n+1 by 2 matrix with the
	    x and y values.  Suitable
	    for plugging into 
	    LinePlotDrawLine or
	    LinePlotDrawPoints.
	  
Example:
genius>LinePlotClear();genius>line = RungeKuttaFull(`(x,y)=y,0,1.0,3.0,50);genius>LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");
	    Systems can be solved by just having y be a
	    (column) vector everywhere.  That is, y0 can
	    be a vector in which case f should take a number
	    x and a vector of the same size for the second
	    argument and should return a vector of the same size.
	  
The output for a system is still a n by 2 matrix with the second entry being a vector. If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with ExpandMatrix, and pick out the right columns. Example:
genius>LinePlotClear();genius>lines = RungeKuttaFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,100);genius>lines = ExpandMatrix(lines);genius>firstline = lines@(,[1,2]);genius>secondline = lines@(,[1,3]);genius>LinePlotWindow = [0,10,-2,2];genius>LinePlotDrawLine(firstline,"color","blue","legend","First");genius>LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");
See Mathworld or Wikipedia for more information.
Version 1.0.10 onwards.