exp-pairs-0.1.5.2: Linear programming over exponent pairs

Copyright(c) Andrew Lelechenko 2014-2015
LicenseGPL-3
Maintainerandrew.lelechenko@gmail.com
Stabilityexperimental
PortabilityPOSIX
Safe HaskellSafe
LanguageHaskell2010

Math.ExpPairs.LinearForm

Description

Provides types for rational forms (to hold objective functions in Math.ExpPairs) and linear contraints (to hold constraints of optimization). Both of them are built atop of projective linear forms.

Synopsis

Documentation

data LinearForm t #

Define an affine linear form of three variables: a*k + b*l + c*m. First argument of LinearForm stands for a, second for b and third for c. Linear forms form a monoid by addition.

Constructors

LinearForm !t !t !t 

Instances

Functor LinearForm # 

Methods

fmap :: (a -> b) -> LinearForm a -> LinearForm b #

(<$) :: a -> LinearForm b -> LinearForm a #

Foldable LinearForm # 

Methods

fold :: Monoid m => LinearForm m -> m #

foldMap :: Monoid m => (a -> m) -> LinearForm a -> m #

foldr :: (a -> b -> b) -> b -> LinearForm a -> b #

foldr' :: (a -> b -> b) -> b -> LinearForm a -> b #

foldl :: (b -> a -> b) -> b -> LinearForm a -> b #

foldl' :: (b -> a -> b) -> b -> LinearForm a -> b #

foldr1 :: (a -> a -> a) -> LinearForm a -> a #

foldl1 :: (a -> a -> a) -> LinearForm a -> a #

toList :: LinearForm a -> [a] #

null :: LinearForm a -> Bool #

length :: LinearForm a -> Int #

elem :: Eq a => a -> LinearForm a -> Bool #

maximum :: Ord a => LinearForm a -> a #

minimum :: Ord a => LinearForm a -> a #

sum :: Num a => LinearForm a -> a #

product :: Num a => LinearForm a -> a #

Eq t => Eq (LinearForm t) # 

Methods

(==) :: LinearForm t -> LinearForm t -> Bool #

(/=) :: LinearForm t -> LinearForm t -> Bool #

Num t => Num (LinearForm t) # 
Show t => Show (LinearForm t) # 
Generic (LinearForm t) # 

Associated Types

type Rep (LinearForm t) :: * -> * #

Methods

from :: LinearForm t -> Rep (LinearForm t) x #

to :: Rep (LinearForm t) x -> LinearForm t #

Num t => Monoid (LinearForm t) # 
NFData t => NFData (LinearForm t) # 

Methods

rnf :: LinearForm t -> () #

(Num t, Eq t, Pretty t) => Pretty (LinearForm t) # 

Methods

pretty :: LinearForm t -> Doc #

prettyList :: [LinearForm t] -> Doc #

type Rep (LinearForm t) # 

scaleLF :: (Num t, Eq t) => t -> LinearForm t -> LinearForm t #

Multiply a linear form by a given coefficient.

evalLF :: Num t => (t, t, t) -> LinearForm t -> t #

Evaluate a linear form a*k + b*l + c*m for given k, l and m.

substituteLF :: (Eq t, Num t) => (LinearForm t, LinearForm t, LinearForm t) -> LinearForm t -> LinearForm t #

Substitute linear forms k, l and m into a given linear form a*k + b*l + c*m to obtain a new linear form.

data RationalForm t #

Define a rational form of two variables, equal to the ratio of two LinearForm.

Constructors

(LinearForm t) :/: (LinearForm t) infix 5 

Instances

Functor RationalForm # 

Methods

fmap :: (a -> b) -> RationalForm a -> RationalForm b #

(<$) :: a -> RationalForm b -> RationalForm a #

Foldable RationalForm # 

Methods

fold :: Monoid m => RationalForm m -> m #

foldMap :: Monoid m => (a -> m) -> RationalForm a -> m #

foldr :: (a -> b -> b) -> b -> RationalForm a -> b #

foldr' :: (a -> b -> b) -> b -> RationalForm a -> b #

foldl :: (b -> a -> b) -> b -> RationalForm a -> b #

foldl' :: (b -> a -> b) -> b -> RationalForm a -> b #

foldr1 :: (a -> a -> a) -> RationalForm a -> a #

foldl1 :: (a -> a -> a) -> RationalForm a -> a #

toList :: RationalForm a -> [a] #

null :: RationalForm a -> Bool #

length :: RationalForm a -> Int #

elem :: Eq a => a -> RationalForm a -> Bool #

maximum :: Ord a => RationalForm a -> a #

minimum :: Ord a => RationalForm a -> a #

sum :: Num a => RationalForm a -> a #

product :: Num a => RationalForm a -> a #

Eq t => Eq (RationalForm t) # 
Num t => Fractional (RationalForm t) # 
Num t => Num (RationalForm t) # 
Show t => Show (RationalForm t) # 
Generic (RationalForm t) # 

Associated Types

type Rep (RationalForm t) :: * -> * #

Methods

from :: RationalForm t -> Rep (RationalForm t) x #

to :: Rep (RationalForm t) x -> RationalForm t #

NFData t => NFData (RationalForm t) # 

Methods

rnf :: RationalForm t -> () #

(Num t, Eq t, Pretty t) => Pretty (RationalForm t) # 
type Rep (RationalForm t) # 
type Rep (RationalForm t) = D1 (MetaData "RationalForm" "Math.ExpPairs.LinearForm" "exp-pairs-0.1.5.2-KDQQQzUDZKwLYnWmNWApiy" False) (C1 (MetaCons ":/:" (InfixI NotAssociative 5) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (LinearForm t))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (LinearForm t)))))

evalRF :: Real t => (Integer, Integer, Integer) -> RationalForm t -> RationalInf #

Evaluate a rational form (a*k + b*l + c*m) / (a'*k + b'*l + c'*m) for given k, l and m.

data IneqType #

Constants to specify the strictness of Constraint.

Constructors

Strict

Strict inequality (>0).

NonStrict

Non-strict inequality (≥0).

Instances

data Constraint t #

A linear constraint of two variables.

Constructors

Constraint !(LinearForm t) !IneqType 

Instances

Functor Constraint # 

Methods

fmap :: (a -> b) -> Constraint a -> Constraint b #

(<$) :: a -> Constraint b -> Constraint a #

Foldable Constraint # 

Methods

fold :: Monoid m => Constraint m -> m #

foldMap :: Monoid m => (a -> m) -> Constraint a -> m #

foldr :: (a -> b -> b) -> b -> Constraint a -> b #

foldr' :: (a -> b -> b) -> b -> Constraint a -> b #

foldl :: (b -> a -> b) -> b -> Constraint a -> b #

foldl' :: (b -> a -> b) -> b -> Constraint a -> b #

foldr1 :: (a -> a -> a) -> Constraint a -> a #

foldl1 :: (a -> a -> a) -> Constraint a -> a #

toList :: Constraint a -> [a] #

null :: Constraint a -> Bool #

length :: Constraint a -> Int #

elem :: Eq a => a -> Constraint a -> Bool #

maximum :: Ord a => Constraint a -> a #

minimum :: Ord a => Constraint a -> a #

sum :: Num a => Constraint a -> a #

product :: Num a => Constraint a -> a #

Eq t => Eq (Constraint t) # 

Methods

(==) :: Constraint t -> Constraint t -> Bool #

(/=) :: Constraint t -> Constraint t -> Bool #

Show t => Show (Constraint t) # 
Generic (Constraint t) # 

Associated Types

type Rep (Constraint t) :: * -> * #

Methods

from :: Constraint t -> Rep (Constraint t) x #

to :: Rep (Constraint t) x -> Constraint t #

NFData t => NFData (Constraint t) # 

Methods

rnf :: Constraint t -> () #

(Num t, Eq t, Pretty t) => Pretty (Constraint t) # 

Methods

pretty :: Constraint t -> Doc #

prettyList :: [Constraint t] -> Doc #

type Rep (Constraint t) # 
type Rep (Constraint t) = D1 (MetaData "Constraint" "Math.ExpPairs.LinearForm" "exp-pairs-0.1.5.2-KDQQQzUDZKwLYnWmNWApiy" False) (C1 (MetaCons "Constraint" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (LinearForm t))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 IneqType))))

checkConstraint :: (Num t, Ord t) => (Integer, Integer, Integer) -> Constraint t -> Bool #

Evaluate a rational form of constraint and compare its value with 0. Strictness depends on the given IneqType.