Represents a physical system in which physics happens. A System m n is a system whose state described using n generalized coordinates (an "n-dimensional" system), where the underlying cartesian coordinate space is m-dimensional.

For the most part, you are supposed to be able to ignore m. m is only provided because it's useful when plotting/drawing the system with a given state back in rectangular coordinates. (The only function that use the m at the moment is underlyingPos)

A System m n's state is described using a Config n (which describes the system in configuration space) or a Phase n (which describes the system in phase space).

Create a system with n generalized coordinates by describing its coordinate space (by a function from the generalized coordinates to the underlying cartesian coordinates), the inertia of each of those underlying coordinates, and the pontential energy function.

The potential energy function is expressed in terms of the genearlized coordinate space's positions.

Convenience wrapper over mkSystem that allows you to specify the potential energy function in terms of the underlying cartesian coordinate space.

Converts the position of generalized coordinates of a system to the coordinates of the system's underlying cartesian coordinate system. Useful for plotting/drawing the system in cartesian space.

Represents the full state of a system of n generalized coordinates in configuration space (informally, "positions and velocities")

A configuration space representaiton is more directly "physically meaningful" and intuitive/understandable to humans than a phase space representation. However, it's much less mathematically ideal to work with because of the lack of some neat underlying symmetries.

You can convert a Config n into a Phase n (convert from configuration space to phase space) for a given system with toPhase. This allows you to state your system in configuration space and then convert it to phase space before handing it off to the hamiltonian machinery.

Represents the full state of a system of n generalized coordinates in phase space (informally, "positions and momentums").

Phase space representations are much nicer to work with mathematically because of some neat underlying symmetries. For one, positions and momentums are "interchangeable" in a system; if you swap every coordinate's positions with their momentums, and also swap them in the equations of motions, you get the same system back. This isn't the case with configuration space representations.

A hamiltonian simulation basically describes the trajectory of each coordinate through phase space, so this is the state of the simulation. However, configuration space representations are much more understandable to humans, so it might be useful to give an initial state in configuration space using Config, and then convert it to a Phase with toPhase.

Convert a configuration-space representaiton of the state of the system to a phase-space representation.

Useful because the hamiltonian simulations use Phase as its working state, but Config is a much more human-understandable and intuitive representation. This allows you to state your starting state in configuration space and convert to phase space for your simulation to use.

Invert toPhase and convert a description of a system's state in phase space to a description of the system's state in configuration space.

Possibly useful for showing the phase space representation of a system's state in a more human-readable/human-understandable way.

Compute the generalized momenta conjugate to each generalized coordinate of a system by giving the configuration-space state of the system.

Note that getting the momenta from a Phase n involves just using phsMomenta.

Compute the rate of change of each generalized coordinate by giving the state of the system in phase space.

Note that getting the velocities from a Config n involves just using cfgVelocities.

The kinetic energy of a system, given the system's state in configuration space.

The kinetic energy of a system, given the system's state in phase space.

The potential energy of a system, given the position in the generalized coordinates of the system.

The Lagrangian of a system (the difference between the kinetic energy and the potential energy), given the system's state in configuration space.

The Hamiltonian of a system (the sum of kinetic energy and the potential energy), given the system's state in phase space.

The "hamiltonian equations" for a given system at a given state in phase space. Returns the rate of change of the positions and conjugate momenta, which can be used to progress the simulation through time.

Computed using the maths derived in https://blog.jle.im/entry/hamiltonian-dynamics-in-haskell.html.

Step a system through phase space over over a single timestep.

Evolve a system using a hamiltonian stepper, with the given initial phase space state.

Evolve a system using a hamiltonian stepper, with the given initial phase space state.

Desired solution times provided as a list instead of a sized Vector. The output list should be the same length as the input list.

Step a system through configuration space over over a single timestep.

Note that the simulation itself still runs in phase space; this function just abstracts over converting to and from phase space for the input and output.

A convenience wrapper for evolveHam that works on configuration space states instead of phase space states.

Note that the simulation itself still runs in phase space; this function just abstracts over converting to and from phase space for the inputs and outputs.

A convenience wrapper for evolveHam' that works on configuration space states instead of phase space states.

Note that the simulation itself still runs in phase space; this function just abstracts over converting to and from phase space for the inputs and outputs.