Added Forward Euler to Haskell #215

Thurii · 2018-07-04T16:15:02Z

No description provided.

lulucca12

You can also beautify the code with hindent, it becomes so better readable 😄

lulucca12 · 2018-07-04T18:58:48Z

chapters/differential_equations/euler/code/haskell/euler.hs

@@ -0,0 +1,13 @@
+solve_euler timestep n = take n $ iterate f 1


Why not camelCase and explicit type signatures are better:

solveEuler :: Num a => a -> Int -> [a] solveEuler timestep n = take n $ iterate f 1

(type signature suggested by ghmod)

lulucca12 · 2018-07-04T18:59:42Z

chapters/differential_equations/euler/code/haskell/euler.hs

+solve_euler timestep n = take n $ iterate f 1
+    where f x = x - 3 * x * timestep
+
+check_result results threshold timestep =


The same here:

checkResult :: [Double] -> Double -> Double -> Bool checkResult results threshold timestep =

lulucca12 · 2018-07-04T19:04:47Z

chapters/differential_equations/euler/code/haskell/euler.hs

+    and $ zipWith check' results [exp $ -3 * i * timestep | i <- [0..]]
+    where check' result solution = abs (result - solution) < threshold
+
+main = let timestep = 0.01;


It is highly recommended to explicit the main type signature, even when it's just

main :: IO()

Thurii · 2018-07-04T21:21:43Z

Hindent is pretty cool!
Set the types to Doubles, didn't realize how generalized checkResult had become.

lulucca12 · 2018-07-04T23:14:34Z

chapters/differential_equations/euler/code/haskell/euler.hs

+solveEuler :: Double -> Int -> [Double]
+solveEuler timestep n = take n $ iterate f 1
+    where
+        f x = x - 3 * x * timestep


I am not sure whats more readable,

solveEuler :: Double -> Int -> [Double] solveEuler timestep n = take n $ iterate f 1 where f x = x - 3 * x * timestep

or

solveEuler :: Double -> Int -> [Double] solveEuler timestep n = take n $ iterate (\x -> x - 3 * x * timestep) 1

What do you think?

The second one

jiegillet · 2018-07-05T00:40:55Z

This is just a personal preference, but Haskel being a functional programming, I think we should emphasize the functions. I believe that the function that calculates the acceleration should be a parameter in solveEuler. This way, the Euler algorithm is general, and we can choose the Newton equations along with the time steps and other parameters down in main . I submitted code for the Verlet algorithm (way at the bottom, not in the text, I should fix that) if you want to see what I mean.

lulucca12 · 2018-07-05T00:55:24Z

@jiegillet I see what you mean, but I asked about implementing the code as a lambda expression or a 'where' expression. Either way I think it could be simpler implementing the function as a parameter, like you said.

lulucca12

A possible solution for using general acceleration functions. As the code gets more dense it could be a great idea creating comments.

lulucca12 · 2018-07-05T01:20:01Z

chapters/differential_equations/euler/code/haskell/euler.hs

@@ -0,0 +1,20 @@
+solveEuler :: Double -> Int -> [Double]


For implementing a general acceleration function it could be:

solveEuler :: (Double -> Double) -> Int -> [Double] solveEuler accFun n = take n $ iterate accFun 1

(note that we don't need the 'timestep' anymore because we can infer it will be implemented in the acceleration function)

I'm maybe overdoing it, but if you want to be more general, something like
solveEuler :: (Particle -> Acceleration) -> Time -> Particle -> [Particle]
would be good, where Particle represents a particle in space-time, something like like
type Particle = (Position, Speed, Acceleration, Time)
the first parameter is the physical model, the second parameter is the time step, because it shouldn't be part of the physical model, and the third parameter is the initial condition.
I'll admit that this kind of general thinking it not represented in any of the other implementations.

I think using Doubles for now is good, but how would you implement the timestep given to the solveEuler function? I think it is unnecessary if we implement it in the acceleration function

Well, in my Verlet implementation (see link in my other comment), everything is either double or list of doubles (to use in more than 1 dimension). Giving them a name only makes it easy to reason about them.
We can't use the tilmestep in the acceleration function, the acceleration function is the f in: dy(t)/dt=f(t,y(t)). You give f any time, place and speed, it tells you what the acceleration is. Once you know the acceleration, you calculate the new position using the tilmestep and whichever method you like, in this case Euler. So these are used in different places.

I think this is what you meant:

solveEuler :: (Double -> Double) -> Double -> Int -> [Double] solveEuler accFun timestep n = take n $ iterate (\x -> x + accFun x * timestep) 1

as now you can pass the timestep and the acceleration function and it calculates the solution. the function (\x -> x + accFun x * timestep) should calculate the change in x for a given time and acceleration generated by the acceleration function.
Is this correct or I misunderstood what you are trying to say with the acceleration function?

This is what I have right now:

solveEuler :: Num a => (a -> a) -> a -> Int -> [a] solveEuler func initVal n = take n $ iterate func initVal

Just pure forward euler and func can be whatever you need.

lulucca12 · 2018-07-05T01:23:00Z

chapters/differential_equations/euler/code/haskell/euler.hs

+main =
+    let timestep = 0.01
+        n = 1
+        threshold = 0.01


adding a value for accFun:

accFun x = x - 3 * x * timestep

Sould the acceleration function be:

accFun x = -3 * x

lulucca12 · 2018-07-05T01:25:36Z

chapters/differential_equations/euler/code/haskell/euler.hs

+        n = 1
+        threshold = 0.01
+    in  putStrLn $
+        if checkResult (solveEuler timestep n) threshold timestep


And then adding the function as a parameter (we do not need timestep anymore):

if checkResult (solveEuler accFun n) threshold timestep

So now with the timestep:

if checkResult (solveEuler accFun timestep n) threshold timestep

Do you think it's better to leave timestep as a parameter in solveEuler, or have it be a part of accFun?
I'm thinking timestep is more closely related to solveEuler and should be a parameter so that you can try different timesteps without having to modify accFunc.

lulucca12

I couldn't make the code smaller, but now I see what was the point of extracting the applied function because you can easily play with exiting the kinematics and checkFun functions.

jiegillet · 2018-07-06T00:12:03Z

chapters/differential_equations/euler/code/haskell/euler.hs

+solveEuler :: Num a => (a -> a) -> a -> Int -> [a]
+solveEuler func initVal n = take n $ iterate func initVal
+
+checkResult :: (Num a, Ord a, Enum a) => [a] -> (a -> a) -> a -> Bool


You can simplify this

checkResult :: (Ord a, Num a, Num t, Enum t) => a -> (t -> a) -> [a] -> Bool checkResult thresh check = and . zipWith (\i k -> abs (check i - k) < thresh) [0..]

jiegillet · 2018-07-06T00:16:29Z

chapters/differential_equations/euler/code/haskell/euler.hs

@@ -0,0 +1,23 @@
+solveEuler :: Num a => (a -> a) -> a -> Int -> [a]


I know that the Julia code returns n values, but this is Haskell, have solveEuler return an infinite list, we can limit ourselves to n values down in main

True. Though now the whole function is feeling kinda off because it's (now more obviously) just solveEuler = iterate. At that point why even define it?

It's a good idea to define it anyway because giving it a name gives it meaning.
In a more general setting, it's really supposed to do more than that, it would have another parameter, the time step, but you included it in kinematics. It's OK like this, though.

After watching Leios's video I think I have a somewhat better idea of what this should look like.
The timestep should definitely be a solveEuler parameter.

jiegillet

Yes, you definitely got it! This is much better structured.
There is one last thing that I think it a typo for you to fix and I can merge.

jiegillet · 2018-07-08T00:39:10Z

chapters/differential_equations/euler/code/haskell/euler.hs

+    let timestep = 0.01
+        n = 100
+        threshold = 0.01
+        checkResult' = checkResult threshold $ exp . (\x -> x - 3 * x * timestep)


I think here it should be (\x -> - 3 * x * timestep)

Added Forward Euler in Haskell

da1a022

june128 added the Implementation This provides an implementation for an algorithm. (Code and maybe md files are edited.) label Jul 4, 2018

lulucca12 suggested changes Jul 4, 2018

View reviewed changes

Add explicit types and apply hindent

eb1cd8d

lulucca12 reviewed Jul 4, 2018

View reviewed changes

jiegillet self-assigned this Jul 5, 2018

lulucca12 suggested changes Jul 5, 2018

View reviewed changes

Generalize solveEuler and checkResults

537be2c

lulucca12 approved these changes Jul 5, 2018

View reviewed changes

jiegillet reviewed Jul 6, 2018

View reviewed changes

Thurii added 2 commits July 6, 2018 11:42

Further generalize checkResult and slim down solveEuler

78ed76a

Move timestep over to solveEuler

0dd8148

jiegillet requested changes Jul 8, 2018

View reviewed changes

Fix Typo

1a39112

jiegillet approved these changes Jul 8, 2018

View reviewed changes

jiegillet merged commit 73f5060 into algorithm-archivists:master Jul 8, 2018

		@@ -0,0 +1,13 @@
		solve_euler timestep n = take n $ iterate f 1

		@@ -0,0 +1,23 @@
		solveEuler :: Num a => (a -> a) -> a -> Int -> [a]

Uh oh!

Added Forward Euler to Haskell #215

Added Forward Euler to Haskell #215

Uh oh!

Conversation

Thurii commented Jul 4, 2018

Uh oh!

lulucca12 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Thurii commented Jul 4, 2018

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jiegillet commented Jul 5, 2018

Uh oh!

lulucca12 commented Jul 5, 2018

Uh oh!

lulucca12 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jiegillet Jul 5, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Thurii Jul 5, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

lulucca12 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jiegillet Jul 6, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jiegillet left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

jiegillet Jul 5, 2018 •

edited

Loading

Thurii Jul 5, 2018 •

edited

Loading

jiegillet Jul 6, 2018 •

edited

Loading