Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

package colorful-monoids

Styled console text output using ANSI escape sequences. This library provides styled text output using ANSI escape sequences. The colored text is modeled as nested Colored values, which form a Monoid. As a result the colored code has a relatively concise form.
package colourista

Convenient interface for printing colourful messages Convenient interface for printing colourful messages based on the ansi-terminal library.
package comfort-blas

Numerical Basic Linear Algebra using BLAS This is a high-level interface to BLAS. It provides support for working on slices of arrays.
package comfort-fftw

High-level interface to FFTW (Fast Fourier Transform) based on comfort-array FFTW claims to be the fastest Fourier Transform in the West. This is a high-level interface to libfftw. We re-use the type classes from netlib-ffi. Features:
- Support of one (audio), two (image), three (video) dimensional data, as well as n-dimensional one.
- Support for batched transformations e.g. for block-wise Fourier transform.
- No normalization like in plain fftw. This is because I see no universally best place to apply normalization.
The use of comfort-array enables to use array shapes tailored to Fourier transforms:
- Shape.Cyclic for data where the n-1-th element can also be accessed via index -1.
- Shape.Half for complex data of a real-to-complex Fourier transform. It saves you from case distinction between even and odd data length and according mistakes.
- Shape.Symmetric for real-to-real Sine and Cosine transforms. They assert that you will always use the appropriate kind for back transformation.
For rather simple examples see the packages align-audio and morbus-meniere. See also package fft.

Linear Programming using GLPK and comfort-array Simple interface to linear programming functions provided by GLPK using the flexible Array shape framework from comfort-array. E.g. you can use Shape.Tuple to convert safely between nested tuples and arrays with the same number of elements.

type X = Shape.Element
type PairShape = Shape.NestedTuple Shape.TupleIndex (X,X)

case Shape.indexTupleFromShape (Shape.static :: PairShape) of
(posIx,negIx) ->
case mapSnd (mapSnd Array.toTuple) <$>
LP.simplex [] [[1.*posIx, (-1).*negIx] ==. 314]
(LP.Minimize,
Array.fromTuple (23,42) :: Array PairShape Double)
of
(Right (LP.Optimal, (absol, (pos, neg)))) ->
printf "absol %f,  pos %f, neg %f\n" absol pos neg
_ -> fail "GLPK solver failed"

Alternatives: coinor-clp, hmatrix-glpk, glpk-hs

package comfort-graph

Graph structure with type parameters for nodes and edges This graph structure is based on Data.Map and allows any Ord type for nodes and allows directed, undirected and more edge types. There is no need to map nodes to integer numbers. This makes handling in applications much more comfortable, thus the package name. This is especially useful for applications where there is no simple mapping of your node identifiers to integers or where the set of nodes is extended or reduced frequently. However, this flexibility comes with some costs. Since the structure is based on Data.Map.Maps, for efficient computing the node type should support fast comparison. The edge type can be freely chosen. This allows great flexibility but it is a bit more cumbersome to do in Haskell 98. Examples of edge types:
- DirEdge: Edges in a directed graph
- UndirEdge: Edges in an undirected graph
- EitherEdge: For graphs containing both directed and undirected edges
- You may define an edge type with an additional identifier in order to support multiple edges between the same pair of nodes.
- Using type functions with the node type as parameter you may even define an edge type for nodes from a Cartesian product, where only "horizontal" and "vertical" edges are allowed.
For examples see the linear-circuit package and its tests. The ResistorCube test demonstrates non-integer node types and the Tree test demonstrates multigraphs. Another application is cabal-sort. Currently the package does not contain any advanced algorithm, just the data structure and some manipulation functions. The package is plain Haskell 98. Related packages:
- fgl: standard package for graph processing with many graph algorithms but cumbersome data structure with Int numbered nodes
package commonmark-pandoc

Bridge between commonmark and pandoc AST. This library provides typeclasses for rendering commonmark to Pandoc types.
package commutative

Commutative binary operations. Please see the README on Github at https://github.com/athanclark/commutative#readme
package compactmap

A read-only memory-efficient key-value store. A read-only key-value store that uses a sorted vector internally
package companion

A Haskell library to provide companion threads. Please see the README on GitHub at https://github.com/commercialhaskell/companion#readme

Page 171 of many | Previous | Next