Merge branch 'master' of https://github.com/DSLsofMath/BScProj2018

Author: Oskar Lundström

Book/style.css

@@ -86,6 +86,12 @@ div#toc ol > li > ul {
     border-radius: 5px;
 }
 
+.center-img {
+    display: block;
+    border: 3px solid #F0F0F0;
+    border-radius: 5px;
+}
+
 .float-img-left, .float-img-right {
     width: 35%;
 }

Physics/src/Calculus/DifferentialCalc.lhs

@@ -26,7 +26,7 @@ average and instantaneous.
 Quotients of differences of functions of the same time describe the
 average rate of change over the time period. For example, an average
 velocity can be described as the difference quotient of difference in
-position divided by difference in time.
+position and difference in time.
 
 $$v_{avg} = \frac{p_2 - p_1}{t_2 - t_1}$$  where $p_n$ is the position
 at time $t_n$.
@@ -43,7 +43,7 @@ $$ \Delta x = x_2 - x_1 $$
 
 Ok, so it's a difference. But what does $x_2$ and $x_1$ mean, and what do they come from?
 $x_2$ and $x_1$ are not explicitly bound anywhere,
-but seems reasonable to assume that $x_i \in x$ or equivalently, that $x$
+but it seems reasonable to assume that $x_i \in \mathbb{R}$ or equivalently, that $x$
 is a function with a subscript index as an argument, that returns a $\mathbb{R}$.
 
 Further, the indices $1,2$ should not be thought of as specific constants,
@@ -73,7 +73,7 @@ calculus we mainly use differences to express two things, as mentioned
 previously. Average rate of change and instantaneous rate of change.
 
 Average rate of change is best described as the difference quotient of
-the difference in y-axis value over an interval of x, divided by the
+the difference in y-axis value over an interval of x, and the
 difference in x-axis value over the same interval.
 
 $$\frac{y(x_b) - y(x_a)}{x_b - x_a}$$.
@@ -138,7 +138,13 @@ which can be used as
 < ghci> carSpeedAtPointsInTime
 < [1.9999999999833333,1.5402980985023251,0.5838486169602084,1.0006797790330592e-2]
 
-We'd also like to model one of the versions of the delta operator, finite difference, in our syntax tree. As the semantic value of our calculus language is the unary real function, the difference used for averages doesn't really fit in well, as it's a binary function (two arguments: $t_2$ and $t_1$). Instead, we'll use the version of delta used for instantants, as it only takes a single point in time as an argument (assuming $h$ is already given).
+We'd also like to model one of the versions of the delta operator,
+finite difference, in our syntax tree. As the semantic value of our
+calculus language is the unary real function, the difference used for
+averages doesn't really fit in well, as it's a binary function (two
+arguments: $t_2$ and $t_1$). Instead, we'll use the version of delta
+used for instants, as it only takes a single point in time as an
+argument (assuming $h$ is already given).
 
 The constructor in our syntax tree is therefore
 
@@ -185,8 +191,8 @@ Introducing *infinitesimals*! From the wikipedia entry on *Leibniz's notation*
 ![](shrinking.png "Real smol boi"){.float-img-right}
 
 So there's a special syntax for differences where the step $h$ is
-infinitely small, and it's called Leibniz's notation. We interpret the
-above quote in mathematical terms:
+infinitely small, and it's called Leibniz's notation. We could naively
+interpret the above quote in mathematical terms as
 
 $$dx = lim_{\Delta x \to 0} \Delta x$$
 
@@ -195,14 +201,19 @@ such that
 $$\forall y(x). D(y) = \frac{dy}{dx} = \frac{lim_{\Delta y \to 0} \Delta y}
                                             {lim_{\Delta x \to 0} \Delta x}$$
 
-where $D$ is the function of differentiation.
+where $D$ is the function of differentiation. However, this doesn't
+quite make sense as $lim_{x \to 0} x = 0$ and we'd be dividing by
+0. The wording here is important: infinitesimals aren't $0$, but
+*infinitely* small! The result is that we can't define infinitesimals
+in terms of limits, but have to treat them as an orthogonal concept.
 
-This definition of derivatives is very appealing, as it suggests a
-very simple and intuitive transition from finite differences to
-infinitesimal differentials. Also, it suggests the possibility of
-manipulating the infinitesimals of the derivative algebraically, which
-might be very useful. However, this concept is generally considered
-too imprecise to be used as the foundation of calculus.
+Except for this minor road bump, this definition of derivatives is
+very appealing, as it suggests a very simple and intuitive transition
+from finite differences to infinitesimal differentials. Also, it
+suggests the possibility of manipulating the infinitesimals of the
+derivative algebraically, which might be very useful. However, this
+concept is generally considered too imprecise to be used as the
+foundation of calculus.
 
 A later section on the same wikipedia entry elaborates a bit:
 
@@ -216,17 +227,17 @@ A later section on the same wikipedia entry elaborates a bit:
  > notations.
 
 What is then the "right" way to do derivatives? As luck would have it,
-not much differently than Leibniz's suggested! The intuitive idea can
-be turned into a precise definition by defining the derivative to be
-the limit of difference quotients of real numbers. Again, from
-wikipedia - Leibniz's notation:
+not much differently than Leibniz's suggested and how we interpreted
+it above! The intuitive idea can be turned into a precise definition
+by defining the derivative to be the limit of difference quotients of
+real numbers. Again, from wikipedia - Leibniz's notation:
 
  > In its modern interpretation, the expression dy/dx should not be read
  > as the division of two quantities dx and dy (as Leibniz had envisioned
  > it); rather, the whole expression should be seen as a single symbol
  > that is shorthand for
  >
- > $$D(x) = lim_{\Delta x \to 0} \frac{\Delta y}{\Delta x}$$
+ > $$D(y) = lim_{\Delta x \to 0} \frac{\Delta y}{\Delta x}$$
 
 which, when $y$ is a function of $x$, and $x$ is the $id$ function for real numbers (which it is in the case of time), is:
 
@@ -238,7 +249,7 @@ D(y) &= lim_{\Delta x \to 0} \frac{\Delta y}{\Delta x} \\
      &= a \mapsto lim_{h \to 0} \frac{y(a + h) - y(a)}{h}
 \end{align*}
 
-There, the definition of derivatives! Not to complicated, was it? We
+There, the definition of derivatives! Not too complicated, was it? We
 can write a simple numerically approximative according to the
 definition like
 
@@ -247,10 +258,11 @@ definition like
 Only when $h$ is infinitely small is `deriveApprox` fully
 accurate. However, as we can't really represent an infinitely small
 number in finite memory, the result will only be approximative, and
-the approximation will get better as $h$ gets smaller. For example,
-let's calculate the slope of $f(x)=x^2$ at $f(3)$. As the slope of
-this parabola is calculated as $k = 2x$, we expect the result of
-`deriveApprox` to approach $k = 2x = 2*3 = 6$ as $h$ gets smaller
+the approximation will (in most cases) get better as $h$ gets
+smaller. For example, let's calculate the slope of $f(x)=x^2$ at
+$x=3$. As the slope of this parabola is calculated as $k = 2x$, we
+expect the result of `deriveApprox` to approach $k = 2x = 2*3 = 6$ as
+$h$ gets smaller
 
 < ghci> deriveApprox (\x -> x^2) 5    3
 < 11
@@ -270,7 +282,7 @@ approximations!
 
 We define a function to symbolically derive a function
 expression. `derive` takes a function expression, and returns the
-derived function expression.
+differentiated function expression.
 
 > derive :: FunExpr -> FunExpr
 
@@ -491,6 +503,7 @@ Intuitively, the identity function is the identity element for function composit
 >     (f', g') -> f' :. g'
 
 > simplify (Delta h f) = Delta h (simplify f)
+> simplify (D (I f')) = simplify f'
 > simplify (D f) = D (simplify f)
 > simplify (I f) = I (simplify f)
 > simplify f = f

Physics/src/Calculus/FunExpr.lhs

@@ -1,4 +1,4 @@
-> module Calculus.FunExpr (FunExpr (..), RealNum) where
+> module Calculus.FunExpr (FunExpr (..), RealNum, RealFunc) where
 >
 > import Test.QuickCheck
 
@@ -16,12 +16,12 @@ $$\frac{d f(x)}{dx} = f'(x)$$
 
 Hmm, these examples left me more confused than before. The
 differentiation function seems to take an expression as an argument,
-and return the derived expression, with regards to a variable. But
-what is an expression represented as a semantic value? It's not a
-number yet, the variable in the body needs to be substituted first in
-order for the expression to be computable. Is it some kind of function
-then? Well, yes it is! If we reinterpret the differentiation
-expressions above, it makes more sense.
+and return the differentiated expression, with regards to a
+variable. But what is an expression represented as a semantic value?
+It's not a number yet, the variable in the body needs to be
+substituted first in order for the expression to be computable. Is it
+some kind of function then? Well, yes it is! If we reinterpret the
+differentiation expressions above, it makes more sense.
 
 $$\frac{d x^2}{dx} = 2x$$
 
@@ -40,15 +40,14 @@ $$D(square) = double$$.
 So the type of unary real functions seems like a great fit for a
 semantic value for calculus, and it is! Great! But... how do we
 represent a real number in Haskell? There is no `Real` type to
-use. Well, for simplicitys sake we can just say that a real number is
-basically the same as a `Double`, and it is (basically). The problem
-with `Double` is that it's of finite precision, so rounding errors may
-occur. We'll have to keep that in mind when doing calculations!
+use. Well, for the sake of simplicity we can just say that a real
+number is basically the same as a `Double`, and really it is
+(basically). The problem with `Double` is that it's of finite
+precision, so rounding errors may occur. We'll have to keep that in
+mind when doing calculations!
 
 > type RealNum = Double
->
-> -- The type of the semantic value of calculus is the unary real function
-> --   RealNum -> RealNum
+> type RealFunc = RealNum -> RealNum
 
 Now, to the syntax. We've concluded that real functions are really
 what calculus is all about, so let's model them. We create a data type
@@ -59,36 +58,31 @@ language.
 
 > data FunExpr
 
-First of all, there's the elementary functions. We can't have them
+First of all, there are the elementary functions. We can't have them
 all, that would get too repetitive to implement, but we'll put in all
 the fun ones.
 
->     = Exp
->     | Log
->     | Sin
->     | Cos
->     | Asin
->     | Acos
+>     = Exp | Log | Sin | Cos | Asin | Acos
 
 Then, there are the arithmetic operators. "But wait", you say, "Aren't
-arithmetic operators used to combine expressions, not functions?". I
-hear you, Billy, but we will do it anyways. We could make a `Lambda`
+arithmetic operators used to combine expressions, not functions?". We
+hear you friend, but we will do it anyways. We could make a `Lambda`
 constructor for "VAR $\mapsto$ EXPR" expressions and define the
 arithmetic operators for the expression type, but this would make
 our language much more complicated! Instead, we'll restrain ourselves
 to single variable expressions, which can be represented as
 compositions of unary functions, and define the arithmeric operators
 for the functions instead.
 
-$$f \text{ OP } g = x \mapsto (f(x) \text{ OP } g(x))$$
+$$f \text{ $OP_{r \to r}$ } g = x \mapsto (f(x) \text{ $OP_r$ } g(x))$$
 
 >     | FunExpr :+ FunExpr
 >     | FunExpr :- FunExpr
 >     | FunExpr :* FunExpr
 >     | FunExpr :/ FunExpr
 >     | FunExpr :^ FunExpr
 
-And then theres that single variable. As everything is a function
+And then there's that single variable. As everything is a function
 expression, the function that best represents "just a variable" would
 be $x \mapsto x$, which is the same as the $id$ function.
 
@@ -98,23 +92,23 @@ In a similar vein, the constant function. $const(c) = x \mapsto c$
 
 >     | Const RealNum
 
-Then theres function composition. If you didn't already know it, it's
+Then there's function composition. If you didn't already know it, it's
 defined as
 
-$$f . g = x \mapsto f(g(x))$$
+$$f \circ g = x \mapsto f(g(x))$$
 
 >     | FunExpr :. FunExpr
 
-Finally, the real heroes: The functions of difference, differentiation,
-and integration! They will be well explored later. But for now, we
+Finally, the real heroes: the functions of difference, differentiation,
+and integration! They will be well explored later. But for now, we just
 define the syntax for them as
 
 >     | Delta RealNum FunExpr
 >     | D FunExpr
 >     | I FunExpr
 
 Even more finally, we add a `deriving` modifier to automatically allow
-for equality tests between `FunExpr`s.
+for syntactic equality tests between `FunExpr`s.
 
 >   deriving Eq
 
@@ -141,7 +135,7 @@ left-associative, and set the precedence.
 > infixl 7 :/
 > -- Higher precedence
 > infixl 8 :^
-> -- Higherer precedence
+> -- Can't go higher than this precedence
 > infixl 9 :.
 
 
@@ -155,7 +149,7 @@ for: `Show` and `Arbitrary`.
 
 Try modifying `FunExpr` to derive `Show`, so that our expressions can be printed.
 
-<   deriving Eq, Show
+<   deriving (Eq, Show)
 
 Consider now how GHCi prints out a function expression we create
 
@@ -167,30 +161,33 @@ Consider now how GHCi prints out a function expression we create
 
 Well that's borderline unreadable. Further, the grokability of a printed expression is very inversely proportional to the size/complexity of the expression, as I'm sure you can imagine.
 
-So if the `Show` is bad, we'll just have to make our own `Show`!
-
-> instance Show FunExpr where
->   show Exp = "exp"
->   show Log = "log"
->   show Sin = "sin"
->   show Cos = "cos"
->   show Asin = "asin"
->   show Acos = "acos"
->   show (f :+ g) = "(" ++ show f ++ " + " ++ show g ++ ")"
->   show (f :- g) = "(" ++ show f ++ " - " ++ show g ++ ")"
->   show (f :* g) = "(" ++ show f ++ " * " ++ show g ++ ")"
->   show (f :/ g) = "(" ++ show f ++ " / " ++ show g ++ ")"
->   show (f :^ g) = "(" ++ show f ++ "^" ++ show g ++ ")"
->   show Id = "x"
->   show (Const x) = showReal x
->   show (f :. g) = "(" ++ show f ++ " . " ++ show g ++ ")"
->   show (Delta h f) = "(delta_" ++ showReal h ++ " " ++ show f ++ ")"
->   show (D f) = "(D " ++ show f ++ ")"
->   show (I f) = "(I " ++ show f ++ ")"
+So if the derived `Show` is bad, we'll just have to make our own `Show`!
+
+> showFe :: FunExpr -> String
+> showFe Exp = "exp"
+> showFe Log = "log"
+> showFe Sin = "sin"
+> showFe Cos = "cos"
+> showFe Asin = "asin"
+> showFe Acos = "acos"
+> showFe (f :+ g) = "(" ++ showFe f ++ " + " ++ showFe g ++ ")"
+> showFe (f :- g) = "(" ++ showFe f ++ " - " ++ showFe g ++ ")"
+> showFe (f :* g) = "(" ++ showFe f ++ " * " ++ showFe g ++ ")"
+> showFe (f :/ g) = "(" ++ showFe f ++ " / " ++ showFe g ++ ")"
+> showFe (f :^ g) = "(" ++ showFe f ++ "^" ++ showFe g ++ ")"
+> showFe Id = "id"
+> showFe (Const x) = showReal x
+> showFe (f :. g) = "(" ++ showFe f ++ " . " ++ showFe g ++ ")"
+> showFe (Delta h f) = "(delta_" ++ showReal h ++ " " ++ showFe f ++ ")"
+> showFe (D f) = "(D " ++ showFe f ++ ")"
+> showFe (I f) = "(I " ++ showFe f ++ ")"
 >
 > showReal x = if isInt x then show (round x) else show x
 >   where isInt x = x == fromInteger (round x)
 
+> instance Show FunExpr where
+>   show = showFe
+
 Not much to explain here. It's just one way to print our syntax tree
 in a more readable way. What's interesting is how we can now print our
 expressions in a much more human friendly way!
@@ -200,7 +197,7 @@ expressions in a much more human friendly way!
 
 Still a bit noisy with all the parentheses, but much better!
 
-Another class we need to instance for our `FunExpr` is
+Another class we can instance for our `FunExpr` is
 `Arbitrary`. This class is associated with the testing library
 *QuickCheck*, and describes how to generate arbitrary values of a type
 for use when testing logical properties with `quickCheck`. For