#*****************************************************************************
#       Copyright (C) 2008 Dean Moore 
#
#  Distributed under the terms of the GNU General Public License (GPL)
#                  http://www.gnu.org/licenses/
#*****************************************************************************  
f(x) = sin(2*x) 

a                      = -pi/4 
b                      = (5/4)*pi 
givenPoints            = [0, pi/2, pi]
thickness_of_curve     = 0.75     
color_of_curve         = (0,0,0) 
color_of_pos           = (0,1,0)
color_of_neg           = (0,0,1)
color_of_zero_line     = (1,0,0)
color_of_sliding_point = (0,0,0)
length_of_deriv_line   = 2
thickness_deriv_line   = 1  
sliding_point_size     = 15       
figure_size            = 5 
delay_between_frames   = 0 
number_of_plot_points  = 100

def color_of_dot(f, x):

    deriv = (f.derivative()).derivative()
    slope = deriv(x)

    if (slope != 0):
        return color_of_sliding_point

    return color_of_zero_line

def color_of_derivative_line(f, x):

    deriv = (f.derivative()).derivative()
    slope = deriv(x)

    if (slope < 0):
        return color_of_pos
    if (slope > 0):
        return color_of_neg

    return color_of_zero_line

def fillInZeros(f, f_prime, a, b, xVals, givenPoints, function_values):
    from copy import copy
    tempxVals = copy(xVals)

    i = var('i')
    numRoots = var('numRoots')
    numRoots = 0
    i = 0

    if (i < len(xVals)):
        dfx = f_prime(xVals[i]) # Derivative of f at x, slight abuse of notation.
 
    for i in srange(0, len(givenPoints)):
        for j in srange(0, len(tempxVals) - 1):
            if ((tempxVals[j] < givenPoints[i]) and (tempxVals[j + 1] > givenPoints[i])):
                tempxVals.insert(j + 1, givenPoints[i])
                j = j + 1
                function_values[givenPoints[i]] = f(givenPoints[i])

    return tempxVals
    
def fillXandYValues(f, a, b, number_of_plot_points, xVals, givenPoints, f_prime, function_values):

  for i in srange(a, b + (b - a)/number_of_plot_points, (b - a)/number_of_plot_points):
        function_values[i] = f(i)
        xVals.append(i)
   return fillInZeros(f, f_prime, a, b, xVals, givenPoints, function_values)

v     = []
xVals = []

length_of_deriv_line /= 2

function_values = {}

f_prime = f.derivative()
 
def deriv_line(x0,x):                                
   return f_prime(x0)*x + ( f(x0) - f_prime(x0)*x0 ) 

xVals = fillXandYValues(f, a, b, number_of_plot_points, xVals, givenPoints, f_prime, function_values) 

bottom_x_points = {}
bottom_y_points = {}
top_x_points    = {}
top_y_points    = {}

for i in range(0, len(xVals)):

    temp = f_prime(xVals[i])
    theta = RDF(arctan(temp))
    c = RDF(cos(theta))
    s = RDF(sin(theta))

    bottom_x_points[xVals[i]] = xVals[i]                  - length_of_deriv_line*c # Bottom x-value of deriv line
    bottom_y_points[xVals[i]] = function_values[xVals[i]] - length_of_deriv_line*s # Bottom y-value of deriv line. 

    top_x_points[xVals[i]]    = xVals[i]                  + length_of_deriv_line*c # Top x-value of deriv line
    top_y_points[xVals[i]]    = function_values[xVals[i]] + length_of_deriv_line*s # Top y-value of deriv line.
  
max_x_val = max(max(top_x_points.values()), max(bottom_x_points.values())) 
min_x_val = min(min(top_x_points.values()), min(bottom_x_points.values())) 
 
max_y_val = max(max(top_y_points.values()), max(bottom_y_points.values())) 
min_y_val = min(min(top_y_points.values()), min(bottom_y_points.values())) 

sliding_deriv_line = animate(line([(bottom_x_points[xVals[i]], bottom_y_points[xVals[i]]),
                                   (top_x_points[xVals[i]], top_y_points[xVals[i]]
                                 )],
                                    thickness = thickness_deriv_line,
                                    rgbcolor = color_of_derivative_line(f, xVals[i]))
                                    for i in range(0, len(xVals))) 

sliding_points      = animate([point((xVals[i], function_values[xVals[i]]),
                               rgbcolor = color_of_dot(f, xVals[i]),
                               pointsize = sliding_point_size)
                               for i in range(0, len(xVals))
                              ],
                               xmin = min_x_val, ymin = min_y_val,
                               xmax = max_x_val, ymax = max_y_val,
                               figsize = [figure_size,figure_size], aspect_ratio = 1
                             )
graph = (plot(f, [a, b], thickness = thickness_of_curve,
                         rgbcolor = color_of_curve))
for i in xVals:
   v.append(graph)
curve = animate(v) 
(curve + sliding_points + sliding_deriv_line).show()