Need to switch branch briefly

Author: erikdsjostrom

Book/build.py

@@ -109,6 +109,7 @@ def build_index(sources):
         ("Differential calculus", "Physics/src/Calculus/DifferentialCalc.lhs"),
         ("Integral calculus", "Physics/src/Calculus/IntegralCalc.lhs"),
         ("Plotting graphs", "Physics/src/Calculus/VisVerApp.lhs"),
+        ("Syntax trees", "Physics/src/Calculus/SyntaxTree.lhs"),
     ]),
     ("Linear algebra", [
         ("Vectors", "Physics/src/Vector/Vector.lhs")

Physics/app/Main.hs

@@ -1,9 +1,4 @@
 module Main where
 
-import Vector.Vector
-import Calculus.Calculus
-
---import Lib
-
 main :: IO ()
 main = undefined

Physics/src/Calculus/SyntaxTree.lhs

@@ -1,14 +1,72 @@
 > module Calculus.SyntaxTree where
 
-> import           Calculus.Calculus as C
+> import           Calculus.FunExpr
+> import           Calculus.DifferentialCalc
+> import           Calculus.IntegralCalc
+
+A fun and useful way to visualize expressions is to model them as trees. In our
+case we want to model $FunExpr$ where the nodes and leaves will be our
+constructors.
+
+In order to do this will import two packages, one for constructing trees and one
+for pretty printing them.
+
 > import           Data.Tree         as T
 > import           Data.Tree.Pretty  as P
 
-Pretty prints expressions as trees
+Now we can construct the function that takes a FunExpr and builds a tree from it.
+Every node is a string representation of the constructor and a list of its
+sub trees (branches).
+
+> makeTree :: FunExpr -> Tree String
+> makeTree (e1 :+ e2)  = Node "+"    [makeTree e1, makeTree e2]
+> makeTree (e1 :- e2)  = Node "-"    [makeTree e1, makeTree e2]
+> makeTree (e1 :* e2)  = Node "*"    [makeTree e1, makeTree e2]
+> makeTree (e1 :/ e2)  = Node "Div"  [makeTree e1, makeTree e2]
+> makeTree (e1 :^ e2)  = Node "**"   [makeTree e1, makeTree e2]
+> makeTree (e1 :. e2)  = Node "o"    [makeTree e1, makeTree e2]
+> makeTree (D e)       = Node "d/dx" [makeTree e]
+> makeTree (Delta r e) = Node "Δ"    [makeTree (Const r), makeTree e]
+> makeTree (I e)       = Node "I"    [makeTree e]
+> makeTree Id          = Node "Id"   []
+> makeTree Exp         = Node "Exp"  []
+> makeTree Log         = Node "Log"  []
+> makeTree Sin         = Node "Sin"  []
+> makeTree Cos         = Node "Cos"  []
+> makeTree Asin        = Node "Asin" []
+> makeTree Acos        = Node "Acos" []
+> makeTree (Const num) = Node (show num) [] --(show (floor num)) [] -- | Note the use of floor
+
+Now we construct trees from our expressions but we still need to print them out.
+For this we'll use the function `drawVerticalTree` which does exactly what its
+name suggests. We can then construct a function to draw expressions.
 
 > printExpr :: FunExpr -> IO ()
 > printExpr = putStrLn . drawVerticalTree . makeTree
 
+Now let's construct a mildly complicated expression
+
+> e = Delta 3 (Delta (negate 5) (I Acos) :. (Acos :* Exp))
+
+And print it out.
+
+< ghci > printExpr e
+<           Δ
+<           |
+<   -----------
+<  /           \
+<  3           o
+<              |
+<         ----------
+<         /          \
+<         Δ          *
+<         |          |
+<        ----       -----
+<       /    \     /     \
+<      -5    I   Acos   Exp
+<            |
+<           Acos
+
 Pretty prints the steps taken when canonifying an expression
 
 > prettyCan :: FunExpr -> IO ()
@@ -34,43 +92,21 @@ Pretty prints syntactic checking of equality
 >     putStrLn $ drawVerticalForest [makeTree e1, makeTree e2]
 >     let c1 = canonify e1
 >         c2 = canonify e2
->       in if c1 == e1 && c2 == e2 then putStrLn "Can't simplify no more" 
+>       in if c1 == e1 && c2 == e2 then putStrLn "Can't simplify no more"
 >                                         >> return False
 >                                  else prettyEqual c1 c2
 
 Syntactic checking of equality
 
 > equal :: FunExpr -> FunExpr -> Bool
-> equal e1 e2 = case e1 == e2 of
->   True  -> True
->   False -> let c1 = canonify e1
->                c2 = canonify e2
->             in case e1 == c1 && c2 == e2 of
->               True  -> False
->               False -> equal c1 c2
+> equal e1 e2 = (e1 == e2) ||
+>                  (let c1 = canonify e1
+>                       c2 = canonify e2
+>                     in (not (e1 == c1 && c2 == e2) && equal c1 c2))
 
 Parse an expression as a Tree of Strings
 
-> makeTree :: FunExpr -> Tree String
-> makeTree (e1 :+ e2)  = Node "+"    [makeTree e1, makeTree e2]
-> makeTree (e1 :- e2)  = Node "-"    [makeTree e1, makeTree e2]
-> makeTree (e1 :* e2)  = Node "*"    [makeTree e1, makeTree e2]
-> makeTree (e1 :/ e2)  = Node "Div"  [makeTree e1, makeTree e2]
-> makeTree (e1 :^ e2)  = Node "**"   [makeTree e1, makeTree e2]
-> makeTree (e1 :. e2)  = Node "o"    [makeTree e1, makeTree e2]
-> makeTree (D e)       = Node "d/dx" [makeTree e]
-> makeTree (Delta r e) = Node "Δ"    [makeTree (Const r), makeTree e]
-> makeTree (I r e)     = Node "I"    [makeTree (Const r), makeTree e]
-> makeTree Id          = Node "Id"   []
-> makeTree Exp         = Node "Exp"  []
-> makeTree Log         = Node "Log"  []
-> makeTree Sin         = Node "Sin"  []
-> makeTree Cos         = Node "Cos"  []
-> makeTree Asin        = Node "Asin" []
-> makeTree Acos        = Node "Acos" []
-> makeTree (Const num) = Node (show (floor num)) [] -- | Note the use of floor
-
-Of course this is all bit too verbose, but I'm keeping it that way until every 
+Of course this is all bit too verbose, but I'm keeping it that way until every
 case is covered, Calculus is a bit of a black box for me right now
 
 > canonify :: FunExpr -> FunExpr
@@ -175,5 +211,3 @@ Dummy expressions
 > e4 = (Const 1 :+ Const 2) :* (Const 3 :+ Const 4)
 > e5 = (Const 1 :+ Const 2) :* (Const 4 :+ Const 3)
 > e6 = Const 2 :+ Const 3 :* Const 8 :* Const 19
-> e7 = (Delta 3 ((Delta (0 - 5) (I 7 Acos)) :. (Acos :* Exp)))
-

Physics/src/Dimensions/Quantity.lhs

@@ -28,7 +28,7 @@ Quantities
 
 > import qualified Dimensions.ValueLevel as V
 > import           Dimensions.TypeLevel  as T
-> import           Prelude               as P hiding (length, div)
+> import           Prelude               as P hiding (length)
 
 We'll now create a data type for quantities and combine dimensions on value-level and type-level. Just as before, a bunch of GHC-extensions are necessary.
 
@@ -65,14 +65,7 @@ Let's get on to the actual data type declaration.
 > data Quantity (d :: T.Dim) (v :: *) where
 >   ValQuantity :: V.Dim -> v -> Quantity d v
 
-<<<<<<< HEAD
-> lift :: Quantity dim a -> a
-> lift (Quantity _ v) = v
-
-`data Quantity` creates a *type constructor*. Which means it takes two *types* (of certain *kinds*) to create another *type* (of a certain *kind*). For comparsion, here's a *value constructor* which takes two *values* (of certain *types*) as input to create another *value* (of a certain *type*).
-=======
 That was sure a mouthful! Let's break it down. `data Quantity (d :: T.Dim) (v :: *)` creates the *type constructor* `Quantity`. A type constructor takes types to create another type. In this case, the type constructor `Quantity` takes a type `d` of *kind* `T.Dim` and a type `v` of *kind* `*` to create the type `Quantity d v`. Let's see it in action
->>>>>>> master
 
 < type ExampleType = Quantity T.Length Double
 
@@ -305,7 +298,7 @@ We often use `Double` as the value holding type. Doing exact comparsions isn't a
 Testing if a quantity is zero is something which might be a common operation. So we define it here.
 
 > isZero :: (Fractional v, Ord v) => Quantity d v -> Bool
-> isZero (ValQuantity _ v) = (abs v) < 0.001
+> isZero (ValQuantity _ v) = abs v < 0.001
 
 
 Arithmetic on quantities
@@ -361,10 +354,10 @@ We quickly realize a pattern, so let's generalize a bit.
 > qmap f (ValQuantity d1 v) = ValQuantity d1 (f v)
 
 > qmap' :: (a -> b) -> Quantity dim a -> Quantity dim b
-> qmap' f (Quantity d v) = Quantity d (f v)
+> qmap' f (ValQuantity d v) = ValQuantity d (f v)
 
 > qfold :: (a -> a -> b) -> Quantity dim a -> Quantity dim a -> Quantity dim b
-> qfold f (Quantity d v1) (Quantity _ v2) = Quantity d (f v1 v2)
+> qfold f (ValQuantity d v1) (ValQuantity _ v2) = ValQuantity d (f v1 v2)
 
 > sinq, cosq, asinq, acosq, atanq, expq, logq :: (Floating v) =>
 >   Quantity One v -> Quantity One v

Physics/src/Dimensions/Usage.lhs

@@ -129,4 +129,4 @@ To wrap up, let's create a function to calculate the kinectic energy à la
 >                   Quantity Energy Double
 > kinecticEnergy m v = m *# v *# v /# two
 >   where
->     two = 2.0 # one
+>     two = 2.0 # one

Physics/src/Dimensions/ValueLevel.lhs

@@ -15,7 +15,7 @@ Value-level dimensions
 >     , luminosity
 >     , one
 >     ) where
-> 
+>
 > import Prelude hiding (length, div)
 
 From the introduction, two things became apparanent:

Physics/src/NewtonianMechanics/SingleParticle.lhs

@@ -1,6 +1,6 @@
 > module NewtonianMechanics.SingleParticle where
 
-< import           Calculus.SyntaxTree
+%< import           Calculus.SyntaxTree
 
 > import           Test.QuickCheck
 
@@ -19,20 +19,16 @@ 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
+> import           Calculus.FunExpr
+> import           Calculus.DifferentialCalc -- Maybe remove
+> import           Calculus.IntegralCalc     -- Maybe remove
 > 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{
+ The mass of a particle is just a scalar value so we'll model it using
+ $FunExpr$.
 
 > 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.
@@ -49,13 +45,13 @@ of function expressions. So our data type is simply:
 
 So now we can create our particles! Let's try it out!
 
-**TODO: IMPLEMENT NUM INSTANCE FOR FunExpr AND REWRITE**
+> particle :: Particle
+> particle = P (V3 (3 * Id * Id) (2 * Id) 1) 3
+
+Let's see what happens when we run this in the interpreter.
 
-```
-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}
-```
+< 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
@@ -84,7 +80,15 @@ 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,
+We can try this out in the interpreter with our newly created particle.
+
+< ghci > velocity particle
+< ((D ((3 * id) * id)) x, (D (2 * id)) y, (D 1) z)
+
+Not very readable but at least we can see that it correctly maps the derivative
+over the components of the vector.
+
+*Acceleration* is defined as the derivative of the velocity with respect to time,
 or the second derivative of the position. More formally:
 
 \begin{equation*}
@@ -140,6 +144,10 @@ mathematically defined as follows:
   \vec{F} = \frac{d \vec{p}}{d t} = \frac{d(m \cdot \vec{v})}{d t}
 \end{equation}
 
+Force is a vector so let's create a type synonym to make this clearer.
+
+> type Force = VectorE
+
 The quantity $m \cdot \vec{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
@@ -153,12 +161,11 @@ namely:
 And thus if the particle is accelerating we can calculate the force that
 must be acting on it, in code this would be:
 
-
-< force :: Particle -> VectorE
-< force p = vmap (* m) a
-<   where
-<     m = mass p
-<     a = acceleration p
+> force :: Particle -> Force
+> force p = vmap (* m) a
+>   where
+>     m = mass p
+>     a = acceleration p
 
 Where the acceleration of particle is found by deriving the velocity of that
 same particle with respect to $t$:
@@ -219,12 +226,45 @@ types.
 >     v  = velocity p
 >     v2 = square v
 
-Work and energy
----------------------
+Potential energy
+-----------------
+
+In classical mechanics potential energy is defined as the energy possed by a
+particle because of its position relative to other particles, its electrical
+charge and other factors. This means that to actually calculate the potential
+energy of a particle we'd have to take into account all other particles that
+populate the system no matter how far apart they are.
+
+Potential energy near Earth
+------------------------------------
+
+Thankfully if we're close to the Earths gravitational field it's ok
+to simplify this problem and only take into account the Earths gravitational
+pull since all other factors are negliable in comparison.
+
+The potential energy for particles affected by gravity is defined with
+mathmatical notation as:
+
+\begin{equation}
+    E_p = m \cdot g \cdot h
+\end{equation}
+where $m$ is the mass of the particle, $h$ its height, and $g$ is the
+acceleration due to gravity (9.82 $m/s^2$).
+
+> potentialEnergy :: Particle -> Energy
+> potentialEnergy p = m * g * h
+>   where
+>     m          = mass p
+>     g          = Const 9.82
+>     (V3 _ _ h) = pos p
+
+Work
+----
 
 If a constant force $\vec{F}$ is applied to a particle that moves from
 position $\vec{r_1}$ to $\vec{r_2}$ then the *work* done by the force is defined
-as the dot product of the force and the vector of displacement.
+as the dot product of the force and the vector of displacement. In mathmatical
+notation this is written as
 
 \begin{equation}
   W = \vec{F} \cdot \Delta \vec{r}
@@ -309,8 +349,8 @@ magnitude of the vector, if the gravitational force originates from O. Hmmm
 
 This seems weird since I don't know what the frame of reference is...
 
-> potentialEnergy :: Particle -> Energy
-> potentialEnergy p = undefined
->   where
->     m          = mass p
->     (V3 x _ _) = pos p
+< potentialEnergy :: Particle -> Energy
+< potentialEnergy p = undefined
+<   where
+<     m          = mass p
+<     (V3 x _ _) = pos p