Started to write this as actual learning material

Author: erikdsjostrom

Physics/src/NewtonianMechanics/SingleParticle.lhs

@@ -1,32 +1,97 @@
 > module NewtonianMechanics.SingleParticle where
 
-> import           Calculus.Calculus
 > import           Calculus.SyntaxTree
 > import           Test.QuickCheck
-> import           Vector.Vector as V
 
 Laws:
 
 - A body remains at rest or in uniform motion unless acted upon by a force.
 - A body acted upon by a force moves in such a manner that the time rate of change of the momentum equals the force.
 - If two bodies exert forces on each other, these forces are equal in magnitude and opposite in direction.
 
-> type Time    = Double
-> type Mass    = FunExpr
+We will begin our journey into classical mechanics by studying point particles.
+A point particle has a mass and it's position is given as vector in three
+dimensions. Of course it could exist in any number of dimensions but we'll stay
+in three dimensions since it is more intuitive and easier to understand. 
+
+The components of the vector are functions over time that gives the particles
+position in each dimension, x, y, and z. Since we've already defined vectors and
+mathmatical functions in previous chapters we won't spend any time on them here
+and instead just import those two modules.
+
+> import           Calculus.Calculus
+> import           Vector.Vector as V
+
+ The mass of a particle is just a numerical value so we'll model it using
+ doubles.
+
+< type Mass = Double
+
+\ignore{
+
+> type Mass = FunExpr
+
+}
+
+We combine the constructor for vectors in three dimensions with the function
+expressions defined in the chapter on mathmatical analysis. We'll call this new
+type `VectorE` to signify that it's a vector of expressions.
+
 > type VectorE = Vector3 FunExpr
 
+Now we are ready to define what the data type for a particle is. As we
+previously stated a point particle has a mass, and a position given as a vector
+of function expressions. So our data type is simply:
 
 > data Particle  = P { pos  :: VectorE -- Position as a function of time, unit m
->                    --, time :: Time   -- Time, unit s
->                    , mass :: Mass   -- Mass, unit kg
+>                    , mass :: Mass    -- Mass, unit kg
 >                    } deriving Show
 
-Velocity, derivative of pos with respect to time
-unit m*s^-1
+So now we can create our particles! Let's try it out!
+
+```
+ghci > let particle = P (V3 (3 :* Id :* Id) (2 :* Id) 1) 3
+ghci > particle
+P {pos = (((3 * id) * id) x, (2 * id) y, 1 z), mass = 3}
+```
+
+We've created our first particle! And as we can see from the print out it's
+accelerating by $3t^2$ in the x-dimension, has a constant velocity of $2
+t$ in the y-dimension, is positioned at $1$ in the z-dimension, and has a
+mass of $3$. 
+
+Velocity & Acceleration
+------------------
+
+Velocity is defined as the derivative of the position with respect to time. More
+formally:
+
+\begin{equation*}
+\vec{v} = \frac{d\vec{p}}{dt}
+\end{equation*}
+
+And since the position of our particles are given as vectors we'll do the
+derivation component-wise. We need not worry about the details of the derivation
+at all since this is all take care of by the Calculus module, all we need to to
+is use the constructor `D` for the derivative and apply it to each of the
+components of the vector. The business of applying something to each component
+of a vector has also already been taken care of! This was the point of `vmap` to
+map a function over the components of the vector. So if we combine them we get a
+rather elegant way of computing the velocity of a particle.
 
 > velocity :: Particle -> VectorE
 > velocity = vmap D . pos
 
+Acceleration is defined as the derivative of the velocity with respect to time,
+or the second derivative of the position. More formally:
+
+\begin{equation*}
+\vec{a} = \frac{d\vec{v}}{dt} = \frac{d^2\vec{p}}{dt^2}
+\end{equation*}
+
+**Exercise** Try to figure out how to define the function for calculating the
+acceleration of a particle
+
 Forces & Newton's second law
 ------------------------------
 
@@ -36,6 +101,8 @@ as follows:
   \vec{F} = \frac{d \vec{p}}{d t} = \frac{d(m \cdot \vec{v})}{d t}
 \end{equation}
 
+
+
 The quantity $m \cdot v$ is what we mean when we say momentum. So the law
 states that the net force on a particle is equal to the rate of change of the
 momentum with respect to time. And since the definition of acceleration is $a =
@@ -48,6 +115,7 @@ momentum with respect to time. And since the definition of acceleration is $a =
 And thus if the particle is accelerating we can calculate the net force that
 must be acting on it, in code this would be:
 
+
 > force :: Particle -> VectorE
 > force p = vmap (* m) a
 >   where