LPFPCore.Mechanics1D

Code from chapter 15 of the book Learn Physics with Functional Programming

Documentation

type Time = R

type TimeStep = R

type Mass = R

type Position = R

type Velocity = R

type Force = R

type State1D = (Time, Position, Velocity)

newtonSecond1D :: Mass -> [State1D -> Force] -> State1D -> (R, R, R)

euler1D :: R -> (State1D -> (R, R, R)) -> State1D -> State1D

updateTXV :: R -> Mass -> [State1D -> Force] -> State1D -> State1D

statesTXV :: R -> Mass -> State1D -> [State1D -> Force] -> [State1D]

velocity1D :: [State1D] -> Time -> Velocity

velocityFtxv :: R -> Mass -> State1D -> [State1D -> Force] -> Time -> Velocity

position1D :: [State1D] -> Time -> Position

positionFtxv :: R -> Mass -> State1D -> [State1D -> Force] -> Time -> Position

springForce :: R -> State1D -> Force

dampedHOForces :: [State1D -> Force]

dampedHOStates :: [State1D]

pingpongPosition :: Time -> Position

pingpongVelocity :: Time -> Velocity

eulerCromer1D :: R -> (State1D -> (R, R, R)) -> State1D -> State1D

updateTXVEC :: R -> Mass -> [State1D -> Force] -> State1D -> State1D

type UpdateFunction s = s -> s

An update function takes a state as input and returns an updated state as output.

type DifferentialEquation s ds = s -> ds

A differential equation takes a state as input and returns as output the rate at which the state is changing.

type NumericalMethod s ds = DifferentialEquation s ds -> UpdateFunction s

A numerical method turns a differential equation into a state-update function.

solver :: NumericalMethod s ds -> DifferentialEquation s ds -> s -> [s]

Given a numerical method, a differential equation, and an initial state, return a list of states.

class RealVectorSpace ds where

A real vector space allows vector addition and scalar multiplication by reals.

Methods

(+++) :: ds -> ds -> ds

scale :: R -> ds -> ds

Instances

RealVectorSpace DParticleFieldState

Defined in LPFPCore.Lorentz

Methods

(+++) :: DParticleFieldState -> DParticleFieldState -> DParticleFieldState

scale :: R -> DParticleFieldState -> DParticleFieldState

RealVectorSpace DParticleState

Defined in LPFPCore.Mechanics3D

Methods

(+++) :: DParticleState -> DParticleState -> DParticleState

scale :: R -> DParticleState -> DParticleState

RealVectorSpace DMultiParticleState

Defined in LPFPCore.MultipleObjects

Methods

(+++) :: DMultiParticleState -> DMultiParticleState -> DMultiParticleState

scale :: R -> DMultiParticleState -> DMultiParticleState

RealVectorSpace (R, R)

Defined in LPFPCore.Mechanics1D

Methods

(+++) :: (R, R) -> (R, R) -> (R, R)

scale :: R -> (R, R) -> (R, R)

RealVectorSpace (R, R, R)

A triple of real numbers is a real vector space.

Defined in LPFPCore.Mechanics1D

Methods

(+++) :: (R, R, R) -> (R, R, R) -> (R, R, R)

scale :: R -> (R, R, R) -> (R, R, R)

class RealVectorSpace ds => Diff s ds where

A type class that expresses a relationship between a state space and a time-derivative-state space.

Methods

shift :: R -> ds -> s -> s

Instances

Diff ParticleFieldState DParticleFieldState

Defined in LPFPCore.Lorentz

Methods

shift :: R -> DParticleFieldState -> ParticleFieldState -> ParticleFieldState

Diff ParticleState DParticleState

Defined in LPFPCore.Mechanics3D

Methods

shift :: R -> DParticleState -> ParticleState -> ParticleState

Diff MultiParticleState DMultiParticleState

Defined in LPFPCore.MultipleObjects

Methods

shift :: R -> DMultiParticleState -> MultiParticleState -> MultiParticleState

Diff State1D (R, R, R)

A triple of real numbers can serve as the time derivative of a State1D.

Defined in LPFPCore.Mechanics1D

Methods

shift :: R -> (R, R, R) -> State1D -> State1D

Diff (Time, Velocity) (R, R)

Defined in LPFPCore.Mechanics1D

Methods

shift :: R -> (R, R) -> (Time, Velocity) -> (Time, Velocity)

euler :: Diff s ds => R -> (s -> ds) -> s -> s

Given a step size, return the numerical method that uses the Euler method with that step size.

rungeKutta4 :: Diff s ds => R -> (s -> ds) -> s -> s

Given a step size, return the numerical method that uses the 4th order Runge Kutta method with that step size.

exponential :: DifferentialEquation (R, R, R) (R, R, R)

update2 :: (R, R, R) -> (R, R, R)

earthGravity :: Mass -> State1D -> Force

type MState = (Time, Mass, Position, Velocity)

earthGravity2 :: MState -> Force

positionFtxv2 :: R -> MState -> [MState -> Force] -> Time -> Position

statesTXV2 :: R -> MState -> [MState -> Force] -> [MState]

updateTXV2 :: R -> [MState -> Force] -> MState -> MState

updateTV' :: R -> Mass -> [(Time, Velocity) -> Force] -> (Time, Velocity) -> (Time, Velocity)

forces :: R -> [State1D -> R]

vdp :: R -> [(R, R)]