The sequence is set up so that –

The pattern for generating new terms relies on the previous two terms and is written as

For any integer value of n 0 or greater.

This is called the renewal equation. It uses information from the current and previous steps to generate future steps. It is also a second order difference equation.

Because it is a difference equation this may be rewritten as follows:

Since this is a difference equation that is linear, a solution can be made from the linear superposition of the known solutions.

This is for 0 or greater integer values of n=0,1,2,3…

This is a system of irrational numbers that always answers with an integer.

Also is the value known as the Golden Section or Golden Ratio.

]]>

The problem is to find the mathematical formulae to describe the motion on a taught string due to a temporary displacement of the string. The string may be treated as a continuous media of linear density with a constant tension . The string is displaced in the vertical direction .

The tension makes an angle to the unperturbed path of the string at the point of displacement and the tension makes an angle to the unperturbed path of the string at the point of displacement.

is constant.

and

Looking at the sum of the forces in the y-direction:

Due to the small angles

Noting the relationship in Figure 2

Note from this relationship:

This can be placed into the equation for the force in the y-direction:

Looking at the sum of the forces in the x-direction:

The small angles mean and

Thus

The only net force is in the y-direction. Using Newton’s second law all of these equations can be combined.

Setting this equal to the force in the y-direction and taking the limit as approaches zero.

Note taking the limit gives the definition of the derivative which generates the second partial derivative with respect to x.

This is called the wave equation the next post will explore properties of this equation.

Python Code To Generarte Figure 1

#!/usr/bin/env python3 import numpy as np import matplotlib.patches as pts import matplotlib.pyplot as plt # Use matplotlib to generate the graphic for the # http://www.physics-geek.us discussion on transverse waves # Using double sided gaussian to show path of the plucked of the string x = np.linspace(-1, 15, 512) f = np.piecewise(x, [x < 8, x >=8], [lambda x: (25/(np.sqrt(2*np.pi)))*(np.exp(-((x-8)**2/40)))-1.5, lambda x: (18/(np.sqrt(2*np.pi)))*(np.exp(-((x-8)**2/5)))+1.3]) # The tension vector in the positive direction. By components. XP = 5.3 YP = 6.8 UP = 1.6 VP = 1.8 # The tension vector in the negative direction. XN = 1.1 YN = 1.5 UN = -1.6 VN = -1.8 # Define lines measuring eta1 and eta2 xeta1 = [5.3, 10.0] yeta1 = [6.8, 6.8] xeta2 = [-2.0, 1.1] yeta2 = [1.5, 1.5] # Define lines measuring x1 and x2 x1 = [5.3, 5.3] y1 = [6.8, 0.0] x2 = [1.1, 1.1] y2 = [1.5, 0.0] # set up the plotting space fig = plt.figure() ax = fig.add_subplot(111) # Plot the path of the string ax.plot(x, f) # Plot the tension vectors ax.arrow(XP, YP, UP, VP, fc="k", ec="k", head_width=0.2, head_length= 0.3 ) ax.arrow(XN, YN, UN, VN, fc="k", ec="k", head_width=0.2, head_length= 0.3 ) # Plot lines for eta and x ax.plot(xeta1, yeta1, 'k--') ax.plot(xeta2, yeta2, 'k--') ax.plot(x1, y1, 'k--') ax.plot(x2, y2, 'k--') # Plot the angles of deflection alpha1 = pts.Arc([5.3, 6.8], 2.0, 2.0, angle=0, theta1=0, theta2=51) ax.add_patch(alpha1) alpha2 = pts.Arc([1.1, 1.5], 2.0, 2.0, angle=0, theta1=180, theta2=231) ax.add_patch(alpha2) # Labels for graph plt.text(1.2, 0.6, r'$\eta_1$', fontsize=16) plt.text(5.8, 4.6, r'$\eta_2$', fontsize=16) plt.text(-1.0, 9.0, r'$\eta$', fontsize=16) plt.text(15.0, -1.0, r'$x$', fontsize=16) plt.text(-2.0, -1.0, r'$\tau_0$', fontsize=16) plt.text(7.0, 9.0, r'$\tau_0$', fontsize=16) plt.text(6.3, 7.1, r'$\alpha_2$', fontsize=16) plt.text(-1.1, 0.8, r'$\alpha_1$', fontsize=16) # The code for removing the axis and replacing with arrows came from # https://github.com/Felix11H/axis_arrowheads # Used with permission from Felix xmin, xmax = ax.get_xlim() ymin, ymax = ax.get_ylim() ymin = ymin ymax = ymax # removing the default axis on all sides: for side in ['bottom','right','top','left']: ax.spines[side].set_visible(False) # removing the axis ticks plt.xticks([]) # labels plt.yticks([]) ax.xaxis.set_ticks_position('none') # tick markers ax.yaxis.set_ticks_position('none') # wider figure for demonstration fig.set_size_inches(6,4) # get width and height of axes object to compute # matching arrowhead length and width dps = fig.dpi_scale_trans.inverted() bbox = ax.get_window_extent().transformed(dps) width, height = bbox.width, bbox.height # manual arrowhead width and length hw = 1./20.*(ymax-ymin) hl = 1./20.*(xmax-xmin) lw = 1. # axis line width ohg = 0.3 # arrow overhang # compute matching arrowhead length and width yhw = hw/(ymax-ymin)*(xmax-xmin)* height/width yhl = hl/(xmax-xmin)*(ymax-ymin)* width/height # draw x and y axis ax.arrow(xmin, 0, xmax-xmin, 0., fc='k', ec='k', lw = lw, head_width=hw, head_length=hl, overhang = ohg, length_includes_head= True, clip_on = False) ax.arrow(0, ymin, 0., ymax-ymin, fc='k', ec='k', lw = lw, head_width=yhw, head_length=yhl, overhang = ohg, length_includes_head= True, clip_on = False) plt.show()

Python Code to Generate Figure 2

#!/usr/bin/env python3 import numpy as np import matplotlib.patches as pts import matplotlib.pyplot as plt # Use matplotlib to generate the graphic for the # http://www.physics-geek.us discussion on transverse waves # set up the plotting space fig = plt.figure() ax = fig.add_subplot(111) # plot tension vector XP = 0.0 YP = 0.0 UP = 1.0 VP = 1.0 ax.arrow(XP, YP, UP, VP, fc="k", ec="k", head_width=0.05, head_length= 0.05 ) # plot eta xeta1 = [1.0, 1.0] yeta1 = [1.0, 0.0] ax.plot(xeta1, yeta1, 'k--') # plot x x1 = [0.0, 1.0] y1 = [0.0, 0.0] ax.plot(x1, y1, 'k--') # plot the angle arch alpha1 = pts.Arc([0.0, 0.0], 0.25, 0.25, angle=0, theta1=0, theta2=45) ax.add_patch(alpha1) # plot the labels plt.text(0.12, 0.05, r'$\alpha_i$', fontsize=16) plt.text(1.025, 0.45, r'$\partial \eta$', fontsize=16) plt.text(0.5, -0.1, r'$\partial x$', fontsize=16) # The code for removing the axis and replacing with arrows came from # https://github.com/Felix11H/axis_arrowheads # Used with permission from Felix xmin, xmax = ax.get_xlim() ymin, ymax = ax.get_ylim() ymin = ymin ymax = ymax # removing the default axis on all sides: for side in ['bottom','right','top','left']: ax.spines[side].set_visible(False) # removing the axis ticks plt.xticks([]) # labels plt.yticks([]) ax.xaxis.set_ticks_position('none') # tick markers ax.yaxis.set_ticks_position('none') # wider figure for demonstration fig.set_size_inches(6,4) plt.show()]]>

This is a commented on phenomena that shows the subtlety in analyzing physics equations. It has been said that a good athlete appears to float in mid-air. The equations of motion for free fall hint at this but let us play with the equations to see this more clearly.

We begin by describing the motion in just the vertical direction. If we have a good athlete that is jumping straight up, which is common in basketball and ballet, and happens to be two of the sports where these phenomena are commonly described.

We are taking a person jumping as our motion. So the force they apply will be converted to an initial velocity. This velocity is the input that defines the rest of the motion. The only other force acting is gravity. So we have a constant acceleration we can calculate the height using the following equation.

We will adapt this for our purposes by defining some reference points

This gives us this format we can use to manipulate these equations:

If we graph height as a function of time we get this shape to the equation.

We want to recognize this quadratic equation is parabolic in time and we can use the vertex solution to define the time it takes to reach the peak height.

Because this is parabolic it is symmetric so our total time of flight is just twice the time it takes to get to the vertex.

Using the time for peak height we solve for the peak height

So we have an idea of how high our jumper will jump given an initial velocity, and how long they will remain in the air. Let us now calculate the length of time they will be higher than half the maximum height. We can do this by solving for one half of the peak height. This will give us two solutions which are the time the jumper first reaches half of peak height and the time the jumper falls back down to half the height. The difference between these two times is the total length of time the jumper will be above half the peak height.

Using the quadratic equation

We can substitute what we found for the peak height back in and we get

The time the jump is above the half peak height is the difference between the two solutions.

The ratio of this time to the total time of flight is

So about 71% of the flight time is in the upper half of the height.

And in the animation below you can see this in the motion of the jumping ball.

So athletes are not floating they are just moving in a constant acceleration. Their vertical motion follows rules. The illusion of floating comes from our perception of the time they are in the air.

The graphs and animation were produced in Mathematica 9. The animation for the gif was produced in Mathematica 9.

v0 = 5; h[t_] := -(1/2) g t^2 + v0 t; g = 9.8; Plot[h[t], {t, 0, (2 v0)/g}, AxesLabel ->{"Height - m", "Time - s"}, PlotRange ->{0, v0^2/(2 g)}, PlotStyle -> {Blue}]

v0 = 5; g = 9.8; h[t_] := -(1/2) g t^2 + v0 t; Animate[ Show[ Plot[ h[t], {t, 0, (2 v0)/g}, AxesLabel -> {"Height - m", "Time - s"}, PlotRange -> {0, v0^2/(2 g) + 0.4`}, PlotStyle -> {Blue, Thick}], Plot[ v0^2/(4 g), {t, 0, (2 v0)/g}, PlotStyle -> {Green, Dashed, Thick}], Graphics[ { PointSize[0.05], Point[ {v0/g, h[t]} ] } ] ], {t, 0, (2 v0)/g} ]

v0 = 5; g = 9.8; h[t_] := -(1/2) g t^2 + v0 t; v = Table[ Show[ Plot[ h[t], {t, 0, (2 v0)/g}, AxesLabel -> {"Time - s", "Height - m"}, PlotRange -> {0, v0^2/(2 g) + 0.4`}, PlotStyle -> {Blue, Thick} ], Plot[ v0^2/(4 g), {t, 0, (2 v0)/g}, PlotStyle -> {Green, Dashed, Thick} ], Graphics[ { PointSize[0.05], Point[ {v0/g, h[t]} ] } ] ], {t, 0, (2 v0)/g, (2 v0)/(50 g)} ] Export["hang_time_10.gif", v, DisplayDurations -> "0.05"]]]>

So here is the Technique as outlined in the book from section 1.2 Parametric Differentiation.

We want to do the definite integral

We do this by making a parameter attached to x.

In this case we will integrate:

If you take the derivative of this equation with respect to the parameter something nice happens.

If we repeat this and take the derivative again

And repeat

And repeat, and repeat, and repeat. This pattern continues.

And this means the nth derivative gives us

If we replace the parameter with 1 we get the result that we expect

So this is the example given in the section. There are two Exercises in the book that explore it. I give some more examples of this technique here as I found it quite interesting and relatively easy if you keep track of your signs.

So we start with Exercise 2

We parametrize this as follows

And we take the first derivative

this gives us

And we take the second derivative

This gives us

We set and collect terms to get

]]>