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

Author: Oskar Lundström

Physics/src/Calculus/DifferentialCalc.lhs

@@ -368,7 +368,17 @@ Again, trivial definition in Haskell
 >                   :* (g :* derive f :+ f :* (Log :. f) :* derive g)
 > derive Id = Const 1
 > derive (Const _) = Const 0
-> derive (f :. g) = derive g :* (derive f :. g)
+
+For a function composition $f \circ g$ we have to handle the case
+where $f$ is a constant function, as we may get division by zero if we
+naively apply the chain rule. We'll make use of the `simplify` function,
+which we'll define later, to reduce compositions of constant functions to
+just constant functions.
+
+> derive (f :. g) =
+>   case simplify f of
+>     Const a -> Const 0
+>     sf      -> (derive sf :. g) :* derive g
 > derive (Delta h f) = Delta h (derive f)
 > derive (D f) = derive (derive f)
 
@@ -441,7 +451,7 @@ For addition and subtraction, it's $0$
 >       -> simplify (Const (a + b) :* f')
 >     (f', g') -> f' :+ g'
 > simplify (f :- g) = case (simplify f, simplify g) of
->     (f', Const 0 :- g') -> f' :+ g'
+>     (f', Const 0 :- g') -> simplify (f' :+ g')
 >     (f', Const 0) -> f'
 >     (Const a, Const b) -> if a > b
 >                           then Const (a - b)
@@ -498,9 +508,10 @@ $$b^{-n} = \frac{1}{b^n}$$
 Intuitively, the identity function is the identity element for function composition
 
 > simplify (f :. g) = case (simplify f, simplify g) of
->     (Id, g') -> g'
->     (f', Id) -> f'
->     (f', g') -> f' :. g'
+>     (Const a, _) -> Const a
+>     (Id, g')     -> g'
+>     (f', Id)     -> f'
+>     (f', g')     -> f' :. g'
 
 > simplify (Delta h f) = Delta h (simplify f)
 > simplify (D (I f')) = simplify f'

Physics/src/Calculus/FunExpr.lhs

@@ -144,8 +144,8 @@ A structure with class
 ----------------------------------------------------------------------
 
 Now that we've defined the basic structure of our language, we can
-instantiate some useful classes. There are two in particular we care
-for: `Show` and `Arbitrary`.
+instantiate some useful classes. There are three in particular we care
+for: `Show`, `Num`, and `Arbitrary`.
 
 Try modifying `FunExpr` to derive `Show`, so that our expressions can be printed.
 
@@ -197,17 +197,33 @@ expressions in a much more human friendly way!
 
 Still a bit noisy with all the parentheses, but much better!
 
-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
-example, a property function could be formulated that states that the
-`:*` constructor of `FunExpr` is associative.
+Another class we can instantiate for our `FunExpr` is `Num`. This
+class allows us to make use of the native Haskell functions and
+operators for numeric operations, instead of writing our own
+constructors. This sometimes improves the readability of the code.
+
+> instance Num FunExpr where
+>   negate e    = Const 0 :- e
+>   (+)         = (:+)
+>   (*)         = (:*)
+>   fromInteger = Const . fromInteger
+>   abs         = undefined
+>   signum      = undefined
+
+Third but not least, we'll instantiate `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 example, a property function could
+be formulated that states that the `:*` constructor of `FunExpr` is
+associative.
 
 The implementation itself is not very interesting. We generate a
 function expression that tends to contain mostly elementary functions,
 arithmetic operations, and a generous dose of constants; with a light
-sprinkle of differences, derivatives, and integrals.
+sprinkle of differences. We won't include derivatives as all
+elementary functions have elementary derivatives anyways, and
+integrals may cause cause approximation errors if we have to
+numerically compute them at evaluation.
 
 > instance Arbitrary FunExpr where
 >   arbitrary =
@@ -223,10 +239,9 @@ generated expressions in complexity.
 >         , (10, return Id)
 >         , (20, fmap Const arbitrary)
 >         , (10, genBinaryApp (:.))
->         , (5 , genBinaryApp Delta)
->         , (5 , fmap D arbitrary)
->         , (5 , fmap I arbitrary) ]
+>         , (5 , genBinaryApp Delta) ]
 >     where genElementary = elements [Exp, Log, Sin, Cos, Asin, Acos]
 >           genBinaryApp op = fmap (\(f, g) -> f `op` g) arbitrary
 >           genBinaryOperation =     elements [(:+), (:-), (:*), (:/), (:^)]
 >                                >>= genBinaryApp
+

Physics/src/Calculus/IntegralCalc.lhs

@@ -502,5 +502,5 @@ figure out the integral further.
 
 > eval (I f) = let _F = simplify (integrate f)
 >              in if _F == (I f)
->                 then integrateApprox (eval f) 0.01 0
+>                 then integrateApprox (eval f) 0.001 0
 >                 else eval _F

Physics/src/Introduction/About.lhs

@@ -39,7 +39,11 @@ The book is aimed at you who have some knowledge of
 sure you could pick it up as we go. We believe in you!
 
 If you wonder about the weird code blocks at the start of many
-chapters, they are there to declare the chapters as Haskell
+chapters,
+
+> module Introduction.About where
+
+they are there to declare the chapters as Haskell
 modules. All chapters are written in *Literate Haskell*, and can be
 used with GHC/GHCi directly as source code. Therefore, you may choose
 to read each chapter as documented source code, rather than text with

Physics/src/Introduction/GettingStarted.lhs

@@ -1,6 +1,4 @@
-
-
-
+> module Introduction.GettingStarted where
 
 What you need to dive in
 ======================================================================

Physics/src/Introduction/WhatIsADsl.lhs

@@ -1,3 +1,5 @@
+> module Introduction.WhatIsADsl where
+
 So what's a DSL?
 ======================================================================
 

Rapport/include/Introduktion.tex

@@ -37,7 +37,7 @@ \section{Bakgrund}
 område. Detta område kan vara databashantering, algebraiska uttryck eller till
 och med fysik. Språket kan antingen vara implementerat inuti ett annat
 programmeringsspråk eller implementerat helt fristående. I kursen och projektet
-är de implementerat i Haskell.
+är de implementerade i Haskell.
 
 Idéen bakom projektet är att använda domänspecifika språk för att ur ett alternativt perspektiv presentera fysik. Likt det sätt DSLsofMath
 presenterar kopplingar mellan matematik och programmering ska projektet på motsvarande sätt visa på kopplingar mellan programmering och fysik och därmed