diff --git a/Bindings/LevMar/CurryFriendly.hs b/Bindings/LevMar/CurryFriendly.hs --- a/Bindings/LevMar/CurryFriendly.hs +++ b/Bindings/LevMar/CurryFriendly.hs @@ -27,9 +27,8 @@ , dlevmar_blec_dif, slevmar_blec_dif ) where - -import Foreign.C.Types ( CFloat, CDouble ) -import Foreign.Ptr ( FunPtr ) +import Prelude ( Double, Float ) +import Foreign.Ptr ( FunPtr ) import qualified Bindings.LevMar as BLM @@ -38,59 +37,59 @@ -- Handy type synonyms used in the curry friendly types. -------------------------------------------------------------------------------- -type BoxConstraints cr a = BLM.LowerBounds cr - → BLM.UpperBounds cr - → a +type BoxConstraints r α = BLM.LowerBounds r + → BLM.UpperBounds r + → α -type LinearConstraints cr a = BLM.ConstraintsMatrix cr - → BLM.ConstraintsVector cr - → BLM.NrOfConstraints - → a +type LinearConstraints r α = BLM.ConstraintsMatrix r + → BLM.ConstraintsVector r + → BLM.NrOfConstraints + → α -------------------------------------------------------------------------------- -- Curry friendly types of the Levenberg-Marquardt algorithms. -------------------------------------------------------------------------------- -type LevMarDif cr = BLM.LevMarDif cr -type LevMarDer cr = FunPtr (BLM.Jacobian cr) → LevMarDif cr -type LevMarBCDif cr = BoxConstraints cr (LevMarDif cr) -type LevMarBCDer cr = BoxConstraints cr (LevMarDer cr) -type LevMarLecDif cr = LinearConstraints cr (LevMarDif cr) -type LevMarLecDer cr = LinearConstraints cr (LevMarDer cr) -type LevMarBLecDif cr = BoxConstraints cr (LinearConstraints cr (BLM.Weights cr → LevMarDif cr)) -type LevMarBLecDer cr = BoxConstraints cr (LinearConstraints cr (BLM.Weights cr → LevMarDer cr)) +type LevMarDif r = BLM.LevMarDif r +type LevMarDer r = FunPtr (BLM.Jacobian r) → LevMarDif r +type LevMarBCDif r = BoxConstraints r (LevMarDif r) +type LevMarBCDer r = BoxConstraints r (LevMarDer r) +type LevMarLecDif r = LinearConstraints r (LevMarDif r) +type LevMarLecDer r = LinearConstraints r (LevMarDer r) +type LevMarBLecDif r = BoxConstraints r (LinearConstraints r (BLM.Weights r → LevMarDif r)) +type LevMarBLecDer r = BoxConstraints r (LinearConstraints r (BLM.Weights r → LevMarDer r)) -------------------------------------------------------------------------------- -- Reordering arguments to create curry friendly variants. -------------------------------------------------------------------------------- -mk_levmar_der ∷ BLM.LevMarDer cr → LevMarDer cr +mk_levmar_der ∷ BLM.LevMarDer r → LevMarDer r mk_levmar_der lma j f = lma f j -mk_levmar_bc_dif ∷ BLM.LevMarBCDif cr → LevMarBCDif cr +mk_levmar_bc_dif ∷ BLM.LevMarBCDif r → LevMarBCDif r mk_levmar_bc_dif lma lb ub f p x m n = lma f p x m n lb ub -mk_levmar_bc_der ∷ BLM.LevMarBCDer cr → LevMarBCDer cr +mk_levmar_bc_der ∷ BLM.LevMarBCDer r → LevMarBCDer r mk_levmar_bc_der lma lb ub j f p x m n = lma f j p x m n lb ub -mk_levmar_lec_dif ∷ BLM.LevMarLecDif cr → LevMarLecDif cr +mk_levmar_lec_dif ∷ BLM.LevMarLecDif r → LevMarLecDif r mk_levmar_lec_dif lma a b k f p x m n = lma f p x m n a b k -mk_levmar_lec_der ∷ BLM.LevMarLecDer cr → LevMarLecDer cr +mk_levmar_lec_der ∷ BLM.LevMarLecDer r → LevMarLecDer r mk_levmar_lec_der lma a b k j f p x m n = lma f j p x m n a b k -mk_levmar_blec_dif ∷ BLM.LevMarBLecDif cr → LevMarBLecDif cr +mk_levmar_blec_dif ∷ BLM.LevMarBLecDif r → LevMarBLecDif r mk_levmar_blec_dif lma lb ub a b k wghts f p x m n = lma f p x m n lb ub a b k wghts -mk_levmar_blec_der ∷ BLM.LevMarBLecDer cr → LevMarBLecDer cr +mk_levmar_blec_der ∷ BLM.LevMarBLecDer r → LevMarBLecDer r mk_levmar_blec_der lma lb ub a b k wghts j f p x m n = lma f j p x m n lb ub a b k wghts @@ -100,52 +99,52 @@ -- 'Bindings.Levmar'. -------------------------------------------------------------------------------- -slevmar_dif ∷ LevMarDif CFloat +slevmar_dif ∷ LevMarDif Float slevmar_dif = BLM.c'slevmar_dif -dlevmar_dif ∷ LevMarDif CDouble +dlevmar_dif ∷ LevMarDif Double dlevmar_dif = BLM.c'dlevmar_dif -slevmar_der ∷ LevMarDer CFloat +slevmar_der ∷ LevMarDer Float slevmar_der = mk_levmar_der BLM.c'slevmar_der -dlevmar_der ∷ LevMarDer CDouble +dlevmar_der ∷ LevMarDer Double dlevmar_der = mk_levmar_der BLM.c'dlevmar_der -slevmar_bc_dif ∷ LevMarBCDif CFloat +slevmar_bc_dif ∷ LevMarBCDif Float slevmar_bc_dif = mk_levmar_bc_dif BLM.c'slevmar_bc_dif -dlevmar_bc_dif ∷ LevMarBCDif CDouble +dlevmar_bc_dif ∷ LevMarBCDif Double dlevmar_bc_dif = mk_levmar_bc_dif BLM.c'dlevmar_bc_dif -slevmar_bc_der ∷ LevMarBCDer CFloat +slevmar_bc_der ∷ LevMarBCDer Float slevmar_bc_der = mk_levmar_bc_der BLM.c'slevmar_bc_der -dlevmar_bc_der ∷ LevMarBCDer CDouble +dlevmar_bc_der ∷ LevMarBCDer Double dlevmar_bc_der = mk_levmar_bc_der BLM.c'dlevmar_bc_der -slevmar_lec_dif ∷ LevMarLecDif CFloat +slevmar_lec_dif ∷ LevMarLecDif Float slevmar_lec_dif = mk_levmar_lec_dif BLM.c'slevmar_lec_dif -dlevmar_lec_dif ∷ LevMarLecDif CDouble +dlevmar_lec_dif ∷ LevMarLecDif Double dlevmar_lec_dif = mk_levmar_lec_dif BLM.c'dlevmar_lec_dif -slevmar_lec_der ∷ LevMarLecDer CFloat +slevmar_lec_der ∷ LevMarLecDer Float slevmar_lec_der = mk_levmar_lec_der BLM.c'slevmar_lec_der -dlevmar_lec_der ∷ LevMarLecDer CDouble +dlevmar_lec_der ∷ LevMarLecDer Double dlevmar_lec_der = mk_levmar_lec_der BLM.c'dlevmar_lec_der -slevmar_blec_dif ∷ LevMarBLecDif CFloat +slevmar_blec_dif ∷ LevMarBLecDif Float slevmar_blec_dif = mk_levmar_blec_dif BLM.c'slevmar_blec_dif -dlevmar_blec_dif ∷ LevMarBLecDif CDouble +dlevmar_blec_dif ∷ LevMarBLecDif Double dlevmar_blec_dif = mk_levmar_blec_dif BLM.c'dlevmar_blec_dif -slevmar_blec_der ∷ LevMarBLecDer CFloat +slevmar_blec_der ∷ LevMarBLecDer Float slevmar_blec_der = mk_levmar_blec_der BLM.c'slevmar_blec_der -dlevmar_blec_der ∷ LevMarBLecDer CDouble +dlevmar_blec_der ∷ LevMarBLecDer Double dlevmar_blec_der = mk_levmar_blec_der BLM.c'dlevmar_blec_der diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2009 Roel van Dijk, Bas van Dijk +Copyright (c) 2009-2011 Roel van Dijk, Bas van Dijk All rights reserved. diff --git a/Numeric/LevMar.hs b/Numeric/LevMar.hs --- a/Numeric/LevMar.hs +++ b/Numeric/LevMar.hs @@ -8,7 +8,7 @@ -------------------------------------------------------------------------------- -- | -- Module: Numeric.LevMar --- Copyright: (c) 2009 - 2010 Roel van Dijk & Bas van Dijk +-- Copyright: (c) 2009 - 2011 Roel van Dijk & Bas van Dijk -- License: BSD-style (see the file LICENSE) -- Maintainer: Roel van Dijk -- Bas van Dijk @@ -28,21 +28,17 @@ -- * Levenberg-Marquardt algorithm. , LevMarable(levmar) - , LinearConstraints - -- * Minimization options. , Options(..) , defaultOpts -- * Constraints , Constraints(..) - , noConstraints + , LinearConstraints -- * Output , Info(..) , StopReason(..) - , CovarMatrix - , LevMarError(..) ) where @@ -52,41 +48,56 @@ ------------------------------------------------------------------------------- -- from base: -import Control.Monad.Instances -- for 'instance Functor (Either a)' +import Control.Monad ( return, mplus ) import Control.Exception ( Exception ) import Data.Typeable ( Typeable ) -import Data.Bool ( otherwise ) import Data.Either ( Either(Left, Right) ) import Data.Function ( ($) ) -import Data.List ( lookup, map, concat, concatMap, length ) -import Data.Maybe ( Maybe(Nothing, Just) - , isJust, fromJust, fromMaybe - ) +import Data.Functor ( (<$>) ) +import Data.Int ( Int ) +import Data.List ( lookup, (++) ) +import Data.Maybe ( Maybe(Nothing, Just), isJust, fromJust, fromMaybe ) +import Data.Monoid ( Monoid(mempty, mappend) ) import Data.Ord ( (<) ) -import Foreign.Marshal.Array ( allocaArray, peekArray, pokeArray, withArray ) -import Foreign.Ptr ( Ptr, nullPtr, plusPtr ) +import Foreign.Marshal.Array ( allocaArray, withArray, peekArray, copyArray ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( ForeignPtr, newForeignPtr_, withForeignPtr ) import Foreign.Storable ( Storable ) -import Foreign.C.Types ( CInt ) -import Prelude ( Enum, Fractional, Real, RealFrac - , Integer, Float, Double - , fromIntegral, realToFrac, toEnum - , (-), error, floor +import Prelude ( Enum, Fractional, RealFrac, Float, Double + , toEnum, (-), (*), error, floor ) import System.IO ( IO ) import System.IO.Unsafe ( unsafePerformIO ) import Text.Read ( Read ) -import Text.Show ( Show ) +import Text.Show ( Show, show ) +#if __GLASGOW_HASKELL__ >= 605 +import GHC.ForeignPtr ( mallocPlainForeignPtrBytes ) +import Prelude ( undefined ) +import Foreign.Storable ( sizeOf ) +#else +import Foreign.ForeignPtr ( mallocForeignPtrArray ) +#endif + #if __GLASGOW_HASKELL__ < 700 import Prelude ( fromInteger ) #endif -- from base-unicode-symbols: import Data.Bool.Unicode ( (∧), (∨) ) -import Data.Eq.Unicode ( (≡), (≢) ) +import Data.Eq.Unicode ( (≢) ) import Data.Function.Unicode ( (∘) ) -import Prelude.Unicode ( (⋅) ) +-- from hmatrix: +import Data.Packed.Vector ( Vector ) +import Data.Packed.Matrix ( Matrix, Element, flatten, rows, reshape ) + +-- from vector: +import qualified Data.Vector.Storable as VS ( unsafeWith, length + , unsafeFromForeignPtr + , length + ) + -- from bindings-levmar: import Bindings.LevMar ( c'LM_INFO_SZ @@ -134,51 +145,29 @@ -------------------------------------------------------------------------------- {-| A functional relation describing measurements represented as a function -from a list of parameters to a list of expected measurements. - - * Ensure that the length of the parameters list equals the length of the - initial parameters list in 'levmar'. - - * Ensure that the length of the ouput list equals the length of the samples - list in 'levmar'. +from a vector of parameters to a vector of expected measurements. -For example: + * Ensure that the length of the parameters vector equals the length of the + initial parameters vector in 'levmar'. -@ -hatfldc :: Model Double -hatfldc [p0, p1, p2, p3] = [ p0 - 1.0 - , p0 - sqrt p1 - , p1 - sqrt p2 - , p3 - 1.0 - ] -@ + * Ensure that the length of the ouput vector equals the length of the samples + vector in 'levmar'. -} -type Model r = [r] → [r] +type Model r = Vector r → Vector r -{-| The jacobian of the 'Model' function. Expressed as a function from a list -of parameters to a list of lists which for each expected measurement describes +{-| The jacobian of the 'Model' function. Expressed as a function from a vector +of parameters to a matrix which for each expected measurement describes the partial derivatives of the parameters. See: - * Ensure that the length of the parameter list equals the length of the initial - parameter list in 'levmar'. + * Ensure that the length of the parameter vector equals the length of the initial + parameter vector in 'levmar'. - * Ensure that the output matrix has the dimension @n@/x/@m@ where @n@ is the + * Ensure that the output matrix has the dimension @n> peekArray c'LM_INFO_SZ infoPtr + let psV = VS.unsafeFromForeignPtr psFP 0 lenPs + let covarM = reshape lenPs $ + VS.unsafeFromForeignPtr covarFP 0 covarLen -convertModel ∷ (Real r, Fractional r, Storable c, Real c, Fractional c) - ⇒ Model r → Bindings.LevMar.Model c -convertModel model = - \parPtr hxPtr numPar _ _ → - peekArray (fromIntegral numPar) parPtr >>= - pokeArray hxPtr ∘ map realToFrac ∘ model ∘ map realToFrac + return $ Right (psV, info, covarM) + where + lenPs = VS.length ps + lenYs = VS.length ys + covarLen = lenPs*lenPs + (cMat, rhcVec) = fromJust mLinC -convertJacobian ∷ (Real r, Fractional r, Storable c, Real c, Fractional c) - ⇒ Jacobian r → Bindings.LevMar.Jacobian c -convertJacobian jac = - \parPtr jPtr numPar _ _ → - peekArray (fromIntegral numPar) parPtr >>= - pokeArray jPtr ∘ concatMap (map realToFrac) ∘ jac ∘ map realToFrac + -- Whether the parameters are constrained by a linear equation. + linConstrained = isJust mLinC --- | Linear constraints consisting of a constraints matrix, /kxm/ and --- a right hand constraints vector, /kx1/ where /m/ is the number of --- parameters and /k/ is the number of constraints. -type LinearConstraints r = ([[r]], [r]) + -- Whether the parameters are constrained by a bounding box. + boxConstrained = isJust mLowBs ∨ isJust mUpBs + withBoxConstraints f g = + maybeWithArray mLowBs $ \lBsPtr → + maybeWithArray mUpBs $ \uBsPtr → + f $ g lBsPtr uBsPtr + withLinConstraints f g = + VS.unsafeWith (flatten cMat) $ \cMatPtr → + VS.unsafeWith rhcVec $ \rhcVecPtr → + f ∘ g cMatPtr rhcVecPtr $ rows cMat + + withWeights f g = maybeWithArray mWeights $ f ∘ g + +maybeWithArray ∷ (Storable α) ⇒ Maybe (Vector α) → (Ptr α → IO β) → IO β +maybeWithArray Nothing f = f nullPtr +maybeWithArray (Just v) f = VS.unsafeWith v f + +#if __GLASGOW_HASKELL__ >= 605 +{-# INLINE fastMallocForeignPtrArray #-} +fastMallocForeignPtrArray ∷ ∀ α. Storable α ⇒ Int → IO (ForeignPtr α) +fastMallocForeignPtrArray n = mallocPlainForeignPtrBytes + (n * sizeOf (undefined ∷ α)) +#else +fastMallocForeignPtrArray ∷ ∀ α. Storable α ⇒ Int → IO (ForeignPtr α) +fastMallocForeignPtrArray = mallocForeignPtrArray +#endif + + -------------------------------------------------------------------------------- -- Minimization options. -------------------------------------------------------------------------------- -- | Minimization options data Options r = - Opts { optScaleInitMu ∷ r -- ^ Scale factor for initial /mu/. - , optStopNormInfJacTe ∷ r -- ^ Stopping thresholds for @||J^T e||_inf@. - , optStopNorm2Dp ∷ r -- ^ Stopping thresholds for @||Dp||_2@. - , optStopNorm2E ∷ r -- ^ Stopping thresholds for @||e||_2@. - , optDelta ∷ r -- ^ Step used in the difference - -- approximation to the Jacobian. If - -- @optDelta<0@, the Jacobian is approximated - -- with central differences which are more - -- accurate (but slower!) compared to the - -- forward differences employed by default. + Opts { optScaleInitMu ∷ !r -- ^ Scale factor for initial /mu/. + , optStopNormInfJacTe ∷ !r -- ^ Stopping thresholds for @||J^T e||_inf@. + , optStopNorm2Dp ∷ !r -- ^ Stopping thresholds for @||Dp||_2@. + , optStopNorm2E ∷ !r -- ^ Stopping thresholds for @||e||_2@. + , optDelta ∷ !r -- ^ Step used in the difference + -- approximation to the Jacobian. If + -- @optDelta<0@, the Jacobian is approximated + -- with central differences which are more + -- accurate (but slower!) compared to the + -- forward differences employed by default. } deriving (Read, Show) -- | Default minimization options @@ -407,21 +445,30 @@ -- Constraints -------------------------------------------------------------------------------- +-- | Ensure that these vectors have the same length as the number of parameters. data Constraints r = Constraints - { lowerBounds ∷ Maybe [r] -- ^ Optional lower bounds - , upperBounds ∷ Maybe [r] -- ^ Optional upper bounds - , weights ∷ Maybe [r] -- ^ Optional weights - , linearConstraints ∷ Maybe (LinearConstraints r) -- ^ Optional linear constraints + { lowerBounds ∷ !(Maybe (Vector r)) -- ^ Optional lower bounds + , upperBounds ∷ !(Maybe (Vector r)) -- ^ Optional upper bounds + , weights ∷ !(Maybe (Vector r)) -- ^ Optional weights + , linearConstraints ∷ !(Maybe (LinearConstraints r)) -- ^ Optional linear constraints } --- | Constraints where all fields are 'Nothing'. -noConstraints ∷ Constraints r -noConstraints = Constraints Nothing Nothing Nothing Nothing +-- | Linear constraints consisting of a constraints matrix, @k> --- Bas van Dijk --- Stability: Experimental --- --- This module provides the Levenberg-Marquardt algorithm specialised --- for curve-fitting. --- --- For additional documentation see the documentation of the levmar C --- library which this library is based on: --- --- --------------------------------------------------------------------------------- - -module Numeric.LevMar.Fitting - ( -- * Model & Jacobian. - Model - , SimpleModel - , Jacobian - , SimpleJacobian - - -- * Levenberg-Marquardt algorithm. - , LevMar.LevMarable - , levmar - - , LevMar.LinearConstraints - - -- * Minimization options. - , LevMar.Options(..) - , LevMar.defaultOpts - - -- * Output - , LevMar.Info(..) - , LevMar.StopReason(..) - , LevMar.CovarMatrix - - , LevMar.LevMarError(..) - ) where - - --------------------------------------------------------------------------------- --- Imports --------------------------------------------------------------------------------- - --- from base: -import Data.Functor ( fmap ) -import Data.Either ( Either ) -import Data.List ( map, unzip ) -import Data.Maybe ( Maybe ) -import Prelude ( Integer ) - --- from levmar: -import qualified Numeric.LevMar as LevMar - - --------------------------------------------------------------------------------- --- Model & Jacobian. --------------------------------------------------------------------------------- - -{-| A functional relation describing measurements represented as a function -from a list of parameters and an x-value to an expected measurement. - - * Ensure that the length of the parameters list equals the lenght of the initial - parameters list in 'levmar'. - -For example, the quadratic function @f(x) = a*x^2 + b*x + c@ can be -written as: - -@ -quad :: 'Num' r => 'Model' r r -quad [a, b, c] x = a*x^2 + b*x + c -@ --} -type Model r a = [r] → (a → r) - --- | This type synonym expresses that usually the @a@ in @'Model' r a@ --- equals the type of the parameters. -type SimpleModel r = Model r r - -{-| The jacobian of the 'Model' function. Expressed as a function from a list -of parameters and an x-value to the partial derivatives of the parameters. - -See: - - * Ensure that the length of the parameters list equals the lenght of the initial - parameters list in 'levmar'. - - * Ensure that the length of the output parameter derivatives list equals the - length of the input parameters list. - -For example, the jacobian of the above @quad@ model can be written as: - -@ -quadJacob :: 'Num' r => 'Jacobian' N3 r r -quadJacob [_, _, _] x = [ x^2 -- with respect to a - , x -- with respect to b - , 1 -- with respect to c - ] -@ - -(Notice you don't have to differentiate for @x@.) --} -type Jacobian r a = [r] → (a → [r]) - --- | This type synonym expresses that usually the @a@ in @'Jacobian' r a@ --- equals the type of the parameters. -type SimpleJacobian r = Jacobian r r - - --------------------------------------------------------------------------------- --- Levenberg-Marquardt algorithm. --------------------------------------------------------------------------------- - --- | The Levenberg-Marquardt algorithm specialised for curve-fitting. -levmar ∷ LevMar.LevMarable r - ⇒ Model r a -- ^ Model - → Maybe (Jacobian r a) -- ^ Optional jacobian - → [r] -- ^ Initial parameters - → [(a, r)] -- ^ Samples - → Integer -- ^ Maximum iterations - → LevMar.Options r -- ^ Minimization options - → LevMar.Constraints r -- ^ Constraints - → Either LevMar.LevMarError ([r], LevMar.Info r, LevMar.CovarMatrix r) -levmar model mJac params samples = - LevMar.levmar (convertModel model) - (fmap convertJacob mJac) - params - ys - where - (xs, ys) = unzip samples - - convertModel mdl = \ps → map (mdl ps) xs - convertJacob jac = \ps → map (jac ps) xs - - --- The End --------------------------------------------------------------------- diff --git a/README.markdown b/README.markdown new file mode 100644 --- /dev/null +++ b/README.markdown @@ -0,0 +1,26 @@ +The Levenberg-Marquardt algorithm is an iterative technique that +finds a local minimum of a function that is expressed as the sum of +squares of nonlinear functions. It has become a standard technique +for nonlinear least-squares problems and can be thought of as a +combination of steepest descent and the Gauss-Newton method. When +the current solution is far from the correct one, the algorithm +behaves like a steepest descent method: slow, but guaranteed to +converge. When the current solution is close to the correct +solution, it becomes a Gauss-Newton method. + +Optional box- and linear constraints can be given. Both single and +double precision floating point types are supported. + +The actual algorithm is implemented in a [C library] which is bundled +with [bindings-levmar] which this package depends on. + +License +======= + +This library depends on [bindings-levmar] which is bundled together +with a [C library] which falls under the GPL. Please be aware of this +when distributing programs linked with this library. For details see +the description and license of [bindings-levmar]. + +[bindings-levmar]: http://hackage.haskell.org/package/bindings-levmar +[C library]: http://www.ics.forth.gr/~lourakis/levmar diff --git a/levmar.cabal b/levmar.cabal --- a/levmar.cabal +++ b/levmar.cabal @@ -1,5 +1,5 @@ name: levmar -version: 0.3 +version: 1.0 cabal-version: >= 1.6 build-type: Simple stability: experimental @@ -7,9 +7,11 @@ Bas van Dijk maintainer: Roel van Dijk Bas van Dijk -copyright: (c) 2009 - 2010 Roel van Dijk & Bas van Dijk +copyright: (c) 2009 - 2011 Roel van Dijk & Bas van Dijk license: BSD3 license-file: LICENSE +homepage: https://github.com/basvandijk/levmar/ +bug-reports: https://github.com/basvandijk/levmar/issues category: Numerical, Math synopsis: An implementation of the Levenberg-Marquardt algorithm description: @@ -27,30 +29,28 @@ double precision floating point types are supported. . The actual algorithm is implemented in a C library which is bundled - with bindings-levmar which this package depends on. See: + with @bindings-levmar@ which this package depends on. See: . . - All modules are self-contained; i.e. each module re-exports all the - things you need to work with it. - . - Also see the @levmar-safe@ package which adds extra type-safety on - top of this package. - . A note regarding the license: . - This library depends on bindings-levmar which is bundled together + This library depends on @bindings-levmar@ which is bundled together with a C library which falls under the GPL. Please be aware of this when distributing programs linked with this library. For details see - the description and license of bindings-levmar. + the description and license of @bindings-levmar@. +extra-source-files: README.markdown + source-repository head - Type: darcs - Location: http://code.haskell.org/levmar + Type: git + Location: git://github.com/basvandijk/levmar.git library build-depends: base >= 3 && < 4.4 , base-unicode-symbols >= 0.1.1 && < 0.3 - , bindings-levmar >= 0.2 && < 0.3 - exposed-modules: Numeric.LevMar, Numeric.LevMar.Fitting + , bindings-levmar >= 1.0 && < 1.1 + , hmatrix >= 0.11 && < 0.12 + , vector >= 0.7 && < 0.8 + exposed-modules: Numeric.LevMar other-modules: Bindings.LevMar.CurryFriendly ghc-options: -Wall