AnimateGraph[string_, p1_, p2_, p3_, finalt_, initθ_, 
          initω_, steps_, start_, stop_, 
          wid_] := 
Module[{new  =  string, pa = p1, 
            pb = p2, pc = p3, tt = initt,  tf  =  finalt, n2 = steps, 
            init = start, final  = stop, 
            width  =  wid}, 
Do[
            PlotGraph[new, β, pb, pc, tf, initθ, initω, 
              n2], {β, init, final, 
              wid}]
];

$id$

Off[General::spell1]

Runge::usage = "Runge[initialtime, finaltime, initialx, initialy, \
numberofsteps].
Uses a fourth order runge kutta algorithm to integrate third order ODE's.  \
The output
is in the form of a table of 3 x steps values.  The first of the three values \
of the set is the x function, 
the second value is the y function, and the third value is the time value, \
for each step";

SetPendParam::usage = "SetPendParam[drivforce,dampen,drivefreq].
This sets the values of the parameters of your derivative functions for the \
ODE solver.  This specifically
puts in the derivative functions for the chaotic pendulum, though you could \
make your own function to set the 
functions and parameters of different derivative functions to solve a \
different problem";

PlotGraph::usage = "PlotGraph[string, drivforce, dampen, drivfreq, \
initt, finalt, initθ, initω, steps].
This gives graphical output of various graphs, depending on the input.  The \
output is a listplot, and the 
string variable input has the options ''θ vs T'',''ω vs T'',''\
θ vs ω'',''poin θ vs ω'' where the two single
quotes indicate the use of double quotes.  The next three inputs are used to \
define the parameters of the system
to be solved, and the remaining inputs are those used by Runge to calculate \
the solution.  The output hides the 
first 20% of the solutions to allow for the transient behavior to \
disappear.";

Initilization of The Required Functions

(*

Runge[initt_, finalt_, 
            initx_, inity_, 
            steps_]
This function will solve any (3^rd) order ODE given the proper input of a vector function F of the form {(Subscript[f, 1]) = (dx/dt), (Subscript[f, 2]) = (dy/dt), 
            (Subscript[f, 3]) = (dz/dt)} using a (4^th) order Runge - 
        Kutta ODE solving algorithm; 

The inputs are as follows : 
                                                                                                                           
 
          Variable Inputs ; 
initt     :   The initial time to integrate forward from; 
finalt    :   The final time to integrate to; 
initx     :   The initial value for x (t); 
inity     :   The initial value for y (t); 
steps     :   The total number of time steps to take; 
 
 
      The output given is in the form of a 3  
        x steps table where each set of values corresponds to one time step with one value for each of the three functions for every time step the data is then stored in that table to call upon in later lines

*)