This package contains a collection of explicit Runge-Kutta methods of various orders, some with fixed-size steps (no error estimate) and some intended for adaptive stepsize (ie, they include an error estimate). There are a couple of test programs which include some adaptive stepsize control, however there is not yet any such routine in the library itself. There is not yet much in the way of documentation. It's version 1.0.2 because the initial version wasn't cabalized.
This is a replacement for runghc which keeps compiled files for fast runtimes when nothing has changed
> Usage: runghc [options] [ghc-options] file [file-arguments]
> -! --compile-only Do not run the script, just compile it
> -? --help Display this help message
This library encourages you to do memoization in three separate steps:
* Create a memoizable function
* Create or select an appropriate memoizer
* Run the memoizer on the memoizable function
Let's start with the first. When you create a memoizable function, you should use the self convention, which is that the first input to the function is self, and all recursive calls are replaced with self. One common convention that goes well with the self convention is using a helper function go, like so:
> fib :: Memoizable (Integer -> Integer)
> fib self = go
> where go 0 = 1
> go 1 = 1
> go n = self (n-1) + self (n-2)
Now for the second. For this example, we need a Memoizer that can handle an Integer input, and an Integer output. Data.MemoCombinators provides integral, which handles any Integral input, and any output. Data.MemoUgly provides memo, which can memoize any function a -> b, given an Ord instance for a.
Third, let's run our memoizers! Since we have decoupled the definition of the memoized function from its actual memoization, we can create multiple memoized versions of the same function if we so desire.
@ import qualified Data.MemoUgly as Ugly import qualified Data.MemoCombinators as MC
fibUgly :: Integer -> Integer fibUgly = runMemo Ugly.memo fib
fibMC :: Integer -> Integer fibMC = runMemo MC.integral fib @
You could easily do the same with Data.MemoTrie.memo, Data.Function.Memoize.memoize, etc.
Using this technique, you can create local memoized functions whose memo tables are garbage collected as soon as they are no longer needed.
The package contains an interpreter for the AM-Language that is introduced in the basic programming course "Algorithmisches Denken und imperative Programmierung" (WS 2011/12 and later) at the University of Bonn.
This package provides a simple function to truncate HTML, preserving tags and preventing cut-off words.
crunghc is a program that acts like runghc. When it executes a Haskell script, it automatically stores a compiled cache of the script to the disk, so that the compilation overhead can be avoided in subsequent runs.
Runtime for fficxx-generated library
This package provides a simple function to truncate HTML in text form. It preserves tags open and close tags, prevents cut-off words and removes trailing empty tags.
shelltestrunner is a cross-platform tool for testing command-line programs (or arbitrary shell commands.) It reads simple declarative tests specifying a command, some input, and the expected output, error output and exit status. Tests can be run selectively, in parallel, with a timeout, in color, and/or with differences highlighted.
testrunner is a framework to run unit tests. It has the following distinguishing features: * It can run unit tests in parallel. * It can run QuickCheck and HUnit tests as well as simple boolean expressions. * It comes with a ready-made main function for your unit test executable. * This main function recognizes command-line arguments to select tests by name and replay QuickCheck tests.