Safe Haskell	None
Language	Haskell98

NumericPrelude.Numeric

Synopsis

Documentation

(+), (-) :: C a => a -> a -> a infixl 6 +, - #

add and subtract elements

(+), (-) :: C a => a -> a -> a infixl 6 +, - #

add and subtract elements

negate :: C a => a -> a #

inverse with respect to +

zero :: C a => a #

zero element of the vector space

subtract :: C a => a -> a -> a #

subtract is (-) with swapped operand order. This is the operand order which will be needed in most cases of partial application.

sum :: C a => [a] -> a #

Sum up all elements of a list. An empty list yields zero.

This function is inappropriate for number types like Peano. Maybe we should make sum a method of Additive. This would also make lengthLeft and lengthRight superfluous.

sum1 :: C a => [a] -> a #

Sum up all elements of a non-empty list. This avoids including a zero which is useful for types where no universal zero is available. ToDo: Should have NonEmpty type.

isZero :: C a => a -> Bool #

(*) :: C a => a -> a -> a infixl 7 #

one :: C a => a #

fromInteger :: C a => Integer -> a #

(^) :: C a => a -> Integer -> a infixr 8 #

The exponent has fixed type Integer in order to avoid an arbitrarily limitted range of exponents, but to reduce the need for the compiler to guess the type (default type). In practice the exponent is most oftenly fixed, and is most oftenly 2. Fixed exponents can be optimized away and thus the expensive computation of Integers doesn't matter. The previous solution used a C constrained type and the exponent was converted to Integer before computation. So the current solution is not less efficient.

A variant of ^ with more flexibility is provided by ringPower.

ringPower :: (C a, C b) => b -> a -> a #

A prefix function of '(Algebra.Ring.^)' with a parameter order that fits the needs of partial application and function composition. It has generalised exponent.

See: Argument order of expNat on http://www.haskell.org/pipermail/haskell-cafe/2006-September/018022.html

sqr :: C a => a -> a #

product :: C a => [a] -> a #

product1 :: C a => [a] -> a #

div, mod :: C a => a -> a -> a infixl 7 `div`, `mod` #

divMod :: C a => a -> a -> (a, a) #

divides :: (C a, C a) => a -> a -> Bool #

even :: (C a, C a) => a -> Bool #

odd :: (C a, C a) => a -> Bool #

(/) :: C a => a -> a -> a infixl 7 #

recip :: C a => a -> a #

fromRational' :: C a => Rational -> a #

(^-) :: C a => a -> Integer -> a infixr 8 #

fieldPower :: (C a, C b) => b -> a -> a #

A prefix function of '(Algebra.Field.^-)'. It has a generalised exponent.

fromRational :: C a => Rational -> a #

Needed to work around shortcomings in GHC.

(^/) :: C a => a -> Rational -> a infixr 8 #

sqrt :: C a => a -> a #

pi :: C a => a #

exp, log :: C a => a -> a #

logBase, (**) :: C a => a -> a -> a infixr 8 #

(^?) :: C a => a -> a -> a infixr 8 #

sin, cos, tan :: C a => a -> a #

asin, acos, atan :: C a => a -> a #

sinh, cosh, tanh :: C a => a -> a #

asinh, acosh, atanh :: C a => a -> a #

abs :: C a => a -> a #

signum :: C a => a -> a #

quot, rem :: C a => a -> a -> a infixl 7 `quot`, `rem` #

quotRem :: C a => a -> a -> (a, a) #

splitFraction :: (C a, C b) => a -> (b, a) #

fraction :: C a => a -> a #

truncate :: (C a, C b) => a -> b #

round :: (C a, C b) => a -> b #

ceiling, floor :: (C a, C b) => a -> b #

approxRational :: (C a, C a) => a -> a -> Rational #

TODO: Should be moved to a continued fraction module.

atan2 :: C a => a -> a -> a #

toRational :: C a => a -> Rational #

Lossless conversion from any representation of a rational to Rational

toInteger :: C a => a -> Integer #

fromIntegral :: (C a, C b) => a -> b #

isUnit :: C a => a -> Bool #

stdAssociate, stdUnit, stdUnitInv :: C a => a -> a #

extendedGCD :: C a => a -> a -> (a, (a, a)) #

Compute the greatest common divisor and solve a respective Diophantine equation.

  (g,(a,b)) = extendedGCD x y ==>
       g==a*x+b*y   &&  g == gcd x y

TODO: This method is not appropriate for the PID class, because there are rings like the one of the multivariate polynomials, where for all x and y greatest common divisors of x and y exist, but they cannot be represented as a linear combination of x and y. TODO: The definition of extendedGCD does not return the canonical associate.

gcd :: C a => a -> a -> a #

The Greatest Common Divisor is defined by:

  gcd x y == gcd y x
  divides z x && divides z y ==> divides z (gcd x y)   (specification)
  divides (gcd x y) x

lcm :: C a => a -> a -> a #

Least common multiple

euclid :: (C a, C a) => (a -> a -> a) -> a -> a -> a #

extendedEuclid :: (C a, C a) => (a -> a -> (a, a)) -> a -> a -> (a, (a, a)) #

type Rational = T Integer #

(%) :: C a => a -> a -> T a infixl 7 #

numerator :: T a -> a #

denominator :: T a -> a #

data Integer :: * #

Invariant: Jn# and Jp# are used iff value doesn't fit in S#

Useful properties resulting from the invariants:

```
abs (S# _) <= abs (Jp# _)
```
```
abs (S# _) <  abs (Jn# _)
```

Instances

Enum Integer	Since: 2.1
Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Eq Integer
Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Integral Integer	Since: 2.0.1
Methods quot :: Integer -> Integer -> Integer # rem :: Integer -> Integer -> Integer # div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # quotRem :: Integer -> Integer -> (Integer, Integer) # divMod :: Integer -> Integer -> (Integer, Integer) # toInteger :: Integer -> Integer #
Num Integer	Since: 2.1
Methods (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # (*) :: Integer -> Integer -> Integer # negate :: Integer -> Integer # abs :: Integer -> Integer # signum :: Integer -> Integer # fromInteger :: Integer -> Integer #
Ord Integer
Methods compare :: Integer -> Integer -> Ordering # (<) :: Integer -> Integer -> Bool # (<=) :: Integer -> Integer -> Bool # (>) :: Integer -> Integer -> Bool # (>=) :: Integer -> Integer -> Bool # max :: Integer -> Integer -> Integer # min :: Integer -> Integer -> Integer #
Read Integer	Since: 2.1
Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] # readPrec :: ReadPrec Integer # readListPrec :: ReadPrec [Integer] #
Real Integer	Since: 2.0.1
Methods toRational :: Integer -> Rational #
Show Integer	Since: 2.1
Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Ix Integer	Since: 2.1
Methods range :: (Integer, Integer) -> [Integer] # index :: (Integer, Integer) -> Integer -> Int # unsafeIndex :: (Integer, Integer) -> Integer -> Int inRange :: (Integer, Integer) -> Integer -> Bool # rangeSize :: (Integer, Integer) -> Int # unsafeRangeSize :: (Integer, Integer) -> Int
Lift Integer
Methods lift :: Integer -> Q Exp #
Arbitrary Integer
Methods arbitrary :: Gen Integer # shrink :: Integer -> [Integer] #
CoArbitrary Integer
Methods coarbitrary :: Integer -> Gen b -> Gen b #
NFData Integer
Methods rnf :: Integer -> () #
Random Integer
Methods randomR :: RandomGen g => (Integer, Integer) -> g -> (Integer, g) # random :: RandomGen g => g -> (Integer, g) # randomRs :: RandomGen g => (Integer, Integer) -> g -> [Integer] # randoms :: RandomGen g => g -> [Integer] # randomRIO :: (Integer, Integer) -> IO Integer # randomIO :: IO Integer #
C Integer #
Methods compare :: Integer -> Integer -> Ordering #
C Integer #
Methods zero :: Integer # (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # negate :: Integer -> Integer #
C Integer #
Methods isZero :: Integer -> Bool #
C Integer #
Methods (*) :: Integer -> Integer -> Integer # one :: Integer # fromInteger :: Integer -> Integer # (^) :: Integer -> Integer -> Integer #
C Integer #
Methods div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # divMod :: Integer -> Integer -> (Integer, Integer) #
C Integer #
Methods isUnit :: Integer -> Bool # stdAssociate :: Integer -> Integer # stdUnit :: Integer -> Integer # stdUnitInv :: Integer -> Integer #
C Integer #
Methods extendedGCD :: Integer -> Integer -> (Integer, (Integer, Integer)) # gcd :: Integer -> Integer -> Integer # lcm :: Integer -> Integer -> Integer #
C Integer #
Methods abs :: Integer -> Integer # signum :: Integer -> Integer #
C Integer #
Methods toRational :: Integer -> Rational #
C Integer #
Methods quot :: Integer -> Integer -> Integer # rem :: Integer -> Integer -> Integer # quotRem :: Integer -> Integer -> (Integer, Integer) #
C Integer #
Methods toInteger :: Integer -> Integer #
C Integer #
Methods splitFraction :: C b => Integer -> (b, Integer) # fraction :: Integer -> Integer # ceiling :: C b => Integer -> b # floor :: C b => Integer -> b # truncate :: C b => Integer -> b # round :: C b => Integer -> b #
C Integer #
Methods up :: Integer -> Integer -> Integer # dn :: Integer -> Integer -> Integer #
C Integer Integer #
Methods (*>) :: Integer -> Integer -> Integer #
C Integer Integer #
Methods basis :: Integer -> [Integer] # flatten :: Integer -> [Integer] # dimension :: Integer -> Integer -> Int #
C Integer Integer #
Methods norm :: Integer -> Integer #
C Integer Integer #
Methods norm :: Integer -> Integer #
C Integer Integer #
Methods norm :: Integer -> Integer #
Sqr Integer Integer #
Methods normSqr :: Integer -> Integer #
C a => C Integer (T a) #
Methods (*>) :: Integer -> T a -> T a #

data Int :: * #

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Instances

Bounded Int	Since: 2.1
Methods minBound :: Int # maxBound :: Int #
Enum Int	Since: 2.1
Methods succ :: Int -> Int # pred :: Int -> Int # toEnum :: Int -> Int # fromEnum :: Int -> Int # enumFrom :: Int -> [Int] # enumFromThen :: Int -> Int -> [Int] # enumFromTo :: Int -> Int -> [Int] # enumFromThenTo :: Int -> Int -> Int -> [Int] #
Eq Int
Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Integral Int	Since: 2.0.1
Methods quot :: Int -> Int -> Int # rem :: Int -> Int -> Int # div :: Int -> Int -> Int # mod :: Int -> Int -> Int # quotRem :: Int -> Int -> (Int, Int) # divMod :: Int -> Int -> (Int, Int) # toInteger :: Int -> Integer #
Num Int	Since: 2.1
Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Ord Int
Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Read Int	Since: 2.1
Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Real Int	Since: 2.0.1
Methods toRational :: Int -> Rational #
Show Int	Since: 2.1
Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Ix Int	Since: 2.1
Methods range :: (Int, Int) -> [Int] # index :: (Int, Int) -> Int -> Int # unsafeIndex :: (Int, Int) -> Int -> Int inRange :: (Int, Int) -> Int -> Bool # rangeSize :: (Int, Int) -> Int # unsafeRangeSize :: (Int, Int) -> Int
Lift Int
Methods lift :: Int -> Q Exp #
Arbitrary Int
Methods arbitrary :: Gen Int # shrink :: Int -> [Int] #
CoArbitrary Int
Methods coarbitrary :: Int -> Gen b -> Gen b #
Storable Int	Since: 2.1
Methods sizeOf :: Int -> Int # alignment :: Int -> Int # peekElemOff :: Ptr Int -> Int -> IO Int # pokeElemOff :: Ptr Int -> Int -> Int -> IO () # peekByteOff :: Ptr b -> Int -> IO Int # pokeByteOff :: Ptr b -> Int -> Int -> IO () # peek :: Ptr Int -> IO Int # poke :: Ptr Int -> Int -> IO () #
NFData Int
Methods rnf :: Int -> () #
Random Int
Methods randomR :: RandomGen g => (Int, Int) -> g -> (Int, g) # random :: RandomGen g => g -> (Int, g) # randomRs :: RandomGen g => (Int, Int) -> g -> [Int] # randoms :: RandomGen g => g -> [Int] # randomRIO :: (Int, Int) -> IO Int # randomIO :: IO Int #
C Int #
Methods zero :: Int # (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # negate :: Int -> Int #
C Int #
Methods isZero :: Int -> Bool #
C Int #
Methods (*) :: Int -> Int -> Int # one :: Int # fromInteger :: Integer -> Int # (^) :: Int -> Integer -> Int #
C Int #
Methods div :: Int -> Int -> Int # mod :: Int -> Int -> Int # divMod :: Int -> Int -> (Int, Int) #
C Int #
Methods isUnit :: Int -> Bool # stdAssociate :: Int -> Int # stdUnit :: Int -> Int # stdUnitInv :: Int -> Int #
C Int #
Methods extendedGCD :: Int -> Int -> (Int, (Int, Int)) # gcd :: Int -> Int -> Int # lcm :: Int -> Int -> Int #
C Int #
Methods abs :: Int -> Int # signum :: Int -> Int #
C Int #
Methods toRational :: Int -> Rational #
C Int #
Methods quot :: Int -> Int -> Int # rem :: Int -> Int -> Int # quotRem :: Int -> Int -> (Int, Int) #
C Int #
Methods toInteger :: Int -> Integer #
C Int #
Methods splitFraction :: C b => Int -> (b, Int) # fraction :: Int -> Int # ceiling :: C b => Int -> b # floor :: C b => Int -> b # truncate :: C b => Int -> b # round :: C b => Int -> b #
C Int Int #
Methods (*>) :: Int -> Int -> Int #
C Int Int #
Methods basis :: Int -> [Int] # flatten :: Int -> [Int] # dimension :: Int -> Int -> Int #
C Int Int #
Methods norm :: Int -> Int #
C Int Int #
Methods norm :: Int -> Int #
C Int Int #
Methods norm :: Int -> Int #
Sqr Int Int #
Methods normSqr :: Int -> Int #
Generic1 k (URec k Int)
Associated Types type Rep1 (URec k Int) (f :: URec k Int -> ) :: k -> # Methods from1 :: f a -> Rep1 (URec k Int) f a # to1 :: Rep1 (URec k Int) f a -> f a #
Functor (URec * Int)
Methods fmap :: (a -> b) -> URec * Int a -> URec * Int b # (<$) :: a -> URec * Int b -> URec * Int a #
Foldable (URec * Int)
Methods fold :: Monoid m => URec * Int m -> m # foldMap :: Monoid m => (a -> m) -> URec * Int a -> m # foldr :: (a -> b -> b) -> b -> URec * Int a -> b # foldr' :: (a -> b -> b) -> b -> URec * Int a -> b # foldl :: (b -> a -> b) -> b -> URec * Int a -> b # foldl' :: (b -> a -> b) -> b -> URec * Int a -> b # foldr1 :: (a -> a -> a) -> URec * Int a -> a # foldl1 :: (a -> a -> a) -> URec * Int a -> a # toList :: URec * Int a -> [a] # null :: URec * Int a -> Bool # length :: URec * Int a -> Int # elem :: Eq a => a -> URec * Int a -> Bool # maximum :: Ord a => URec * Int a -> a # minimum :: Ord a => URec * Int a -> a # sum :: Num a => URec * Int a -> a # product :: Num a => URec * Int a -> a #
Traversable (URec * Int)
Methods traverse :: Applicative f => (a -> f b) -> URec * Int a -> f (URec * Int b) # sequenceA :: Applicative f => URec * Int (f a) -> f (URec * Int a) # mapM :: Monad m => (a -> m b) -> URec * Int a -> m (URec * Int b) # sequence :: Monad m => URec * Int (m a) -> m (URec * Int a) #
Eq (URec k Int p)
Methods (==) :: URec k Int p -> URec k Int p -> Bool # (/=) :: URec k Int p -> URec k Int p -> Bool #
Ord (URec k Int p)
Methods compare :: URec k Int p -> URec k Int p -> Ordering # (<) :: URec k Int p -> URec k Int p -> Bool # (<=) :: URec k Int p -> URec k Int p -> Bool # (>) :: URec k Int p -> URec k Int p -> Bool # (>=) :: URec k Int p -> URec k Int p -> Bool # max :: URec k Int p -> URec k Int p -> URec k Int p # min :: URec k Int p -> URec k Int p -> URec k Int p #
Show (URec k Int p)
Methods showsPrec :: Int -> URec k Int p -> ShowS # show :: URec k Int p -> String # showList :: [URec k Int p] -> ShowS #
Generic (URec k Int p)
Associated Types type Rep (URec k Int p) :: * -> * # Methods from :: URec k Int p -> Rep (URec k Int p) x # to :: Rep (URec k Int p) x -> URec k Int p #
data URec k Int	Used for marking occurrences of `Int#` Since: 4.9.0.0
data URec k Int = UInt { uInt# :: Int# }
type Rep1 k (URec k Int)
type Rep1 k (URec k Int) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UInt" PrefixI True) (S1 k (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt k)))
type Rep (URec k Int p)
type Rep (URec k Int p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UInt" PrefixI True) (S1 * (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt *)))

data Float :: * #

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Instances

Eq Float
Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Floating Float	Since: 2.1
Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # sqrt :: Float -> Float # (**) :: Float -> Float -> Float # logBase :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float # log1p :: Float -> Float # expm1 :: Float -> Float # log1pexp :: Float -> Float # log1mexp :: Float -> Float #
Ord Float
Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Read Float	Since: 2.1
Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
RealFloat Float	Since: 2.1
Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # exponent :: Float -> Int # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isNaN :: Float -> Bool # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # isIEEE :: Float -> Bool # atan2 :: Float -> Float -> Float #
Lift Float
Methods lift :: Float -> Q Exp #
Arbitrary Float
Methods arbitrary :: Gen Float # shrink :: Float -> [Float] #
CoArbitrary Float
Methods coarbitrary :: Float -> Gen b -> Gen b #
Storable Float	Since: 2.1
Methods sizeOf :: Float -> Int # alignment :: Float -> Int # peekElemOff :: Ptr Float -> Int -> IO Float # pokeElemOff :: Ptr Float -> Int -> Float -> IO () # peekByteOff :: Ptr b -> Int -> IO Float # pokeByteOff :: Ptr b -> Int -> Float -> IO () # peek :: Ptr Float -> IO Float # poke :: Ptr Float -> Float -> IO () #
NFData Float
Methods rnf :: Float -> () #
Random Float
Methods randomR :: RandomGen g => (Float, Float) -> g -> (Float, g) # random :: RandomGen g => g -> (Float, g) # randomRs :: RandomGen g => (Float, Float) -> g -> [Float] # randoms :: RandomGen g => g -> [Float] # randomRIO :: (Float, Float) -> IO Float # randomIO :: IO Float #
C Float #
Methods zero :: Float # (+) :: Float -> Float -> Float # (-) :: Float -> Float -> Float # negate :: Float -> Float #
C Float #
Methods isZero :: Float -> Bool #
C Float #
Methods (*) :: Float -> Float -> Float # one :: Float # fromInteger :: Integer -> Float # (^) :: Float -> Integer -> Float #
C Float #
Methods abs :: Float -> Float # signum :: Float -> Float #
C Float #
Methods (/) :: Float -> Float -> Float # recip :: Float -> Float # fromRational' :: Rational -> Float # (^-) :: Float -> Integer -> Float #
C Float #
Methods toRational :: Float -> Rational #
C Float #
Methods sqrt :: Float -> Float # root :: Integer -> Float -> Float # (^/) :: Float -> Rational -> Float #
C Float #
Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # logBase :: Float -> Float -> Float # (**) :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float #
C Float #
Methods splitFraction :: C b => Float -> (b, Float) # fraction :: Float -> Float # ceiling :: C b => Float -> b # floor :: C b => Float -> b # truncate :: C b => Float -> b # round :: C b => Float -> b #
C Float #

C Float #
Methods atan2 :: Float -> Float -> Float #
C Float #
Methods radix :: Float -> Integer # digits :: Float -> Int # range :: Float -> (Int, Int) # decode :: Float -> (Integer, Int) # encode :: Integer -> Int -> Float # exponent :: Float -> Int # significand :: Float -> Float # scale :: Int -> Float -> Float # isNaN :: Float -> Bool # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # isIEEE :: Float -> Bool #
Power Float #
Methods power :: Rational -> T Float -> T Float #
C Float Float #
Methods (*>) :: Float -> Float -> Float #
C Float Float #

C Float Float #
Methods basis :: Float -> [Float] # flatten :: Float -> [Float] # dimension :: Float -> Float -> Int #
C Float Float #
Methods toScalar :: Float -> Float # toMaybeScalar :: Float -> Maybe Float # fromScalar :: Float -> Float #
C Float Float #
Methods norm :: Float -> Float #
C Float Float #
Methods norm :: Float -> Float #
C Float Float #
Methods norm :: Float -> Float #
Sqr Float Float #
Methods normSqr :: Float -> Float #
Generic1 k (URec k Float)
Associated Types type Rep1 (URec k Float) (f :: URec k Float -> ) :: k -> # Methods from1 :: f a -> Rep1 (URec k Float) f a # to1 :: Rep1 (URec k Float) f a -> f a #
Functor (URec * Float)
Methods fmap :: (a -> b) -> URec * Float a -> URec * Float b # (<$) :: a -> URec * Float b -> URec * Float a #
Foldable (URec * Float)
Methods fold :: Monoid m => URec * Float m -> m # foldMap :: Monoid m => (a -> m) -> URec * Float a -> m # foldr :: (a -> b -> b) -> b -> URec * Float a -> b # foldr' :: (a -> b -> b) -> b -> URec * Float a -> b # foldl :: (b -> a -> b) -> b -> URec * Float a -> b # foldl' :: (b -> a -> b) -> b -> URec * Float a -> b # foldr1 :: (a -> a -> a) -> URec * Float a -> a # foldl1 :: (a -> a -> a) -> URec * Float a -> a # toList :: URec * Float a -> [a] # null :: URec * Float a -> Bool # length :: URec * Float a -> Int # elem :: Eq a => a -> URec * Float a -> Bool # maximum :: Ord a => URec * Float a -> a # minimum :: Ord a => URec * Float a -> a # sum :: Num a => URec * Float a -> a # product :: Num a => URec * Float a -> a #
Traversable (URec * Float)
Methods traverse :: Applicative f => (a -> f b) -> URec * Float a -> f (URec * Float b) # sequenceA :: Applicative f => URec * Float (f a) -> f (URec * Float a) # mapM :: Monad m => (a -> m b) -> URec * Float a -> m (URec * Float b) # sequence :: Monad m => URec * Float (m a) -> m (URec * Float a) #
Eq (URec k Float p)
Methods (==) :: URec k Float p -> URec k Float p -> Bool # (/=) :: URec k Float p -> URec k Float p -> Bool #
Ord (URec k Float p)
Methods compare :: URec k Float p -> URec k Float p -> Ordering # (<) :: URec k Float p -> URec k Float p -> Bool # (<=) :: URec k Float p -> URec k Float p -> Bool # (>) :: URec k Float p -> URec k Float p -> Bool # (>=) :: URec k Float p -> URec k Float p -> Bool # max :: URec k Float p -> URec k Float p -> URec k Float p # min :: URec k Float p -> URec k Float p -> URec k Float p #
Show (URec k Float p)
Methods showsPrec :: Int -> URec k Float p -> ShowS # show :: URec k Float p -> String # showList :: [URec k Float p] -> ShowS #
Generic (URec k Float p)
Associated Types type Rep (URec k Float p) :: * -> * # Methods from :: URec k Float p -> Rep (URec k Float p) x # to :: Rep (URec k Float p) x -> URec k Float p #
data URec k Float	Used for marking occurrences of `Float#` Since: 4.9.0.0
data URec k Float = UFloat { uFloat# :: Float# }
type Rep1 k (URec k Float)
type Rep1 k (URec k Float) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UFloat" PrefixI True) (S1 k (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat k)))
type Rep (URec k Float p)
type Rep (URec k Float p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UFloat" PrefixI True) (S1 * (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat *)))

data Double :: * #

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double
Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Floating Double	Since: 2.1
Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # sqrt :: Double -> Double # (**) :: Double -> Double -> Double # logBase :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double # log1p :: Double -> Double # expm1 :: Double -> Double # log1pexp :: Double -> Double # log1mexp :: Double -> Double #
Ord Double
Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Read Double	Since: 2.1
Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
RealFloat Double	Since: 2.1
Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # exponent :: Double -> Int # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isNaN :: Double -> Bool # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # isIEEE :: Double -> Bool # atan2 :: Double -> Double -> Double #
Lift Double
Methods lift :: Double -> Q Exp #
Arbitrary Double
Methods arbitrary :: Gen Double # shrink :: Double -> [Double] #
CoArbitrary Double
Methods coarbitrary :: Double -> Gen b -> Gen b #
Storable Double	Since: 2.1
Methods sizeOf :: Double -> Int # alignment :: Double -> Int # peekElemOff :: Ptr Double -> Int -> IO Double # pokeElemOff :: Ptr Double -> Int -> Double -> IO () # peekByteOff :: Ptr b -> Int -> IO Double # pokeByteOff :: Ptr b -> Int -> Double -> IO () # peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
NFData Double
Methods rnf :: Double -> () #
Random Double
Methods randomR :: RandomGen g => (Double, Double) -> g -> (Double, g) # random :: RandomGen g => g -> (Double, g) # randomRs :: RandomGen g => (Double, Double) -> g -> [Double] # randoms :: RandomGen g => g -> [Double] # randomRIO :: (Double, Double) -> IO Double # randomIO :: IO Double #
C Double #
Methods zero :: Double # (+) :: Double -> Double -> Double # (-) :: Double -> Double -> Double # negate :: Double -> Double #
C Double #
Methods isZero :: Double -> Bool #
C Double #
Methods (*) :: Double -> Double -> Double # one :: Double # fromInteger :: Integer -> Double # (^) :: Double -> Integer -> Double #
C Double #
Methods abs :: Double -> Double # signum :: Double -> Double #
C Double #
Methods (/) :: Double -> Double -> Double # recip :: Double -> Double # fromRational' :: Rational -> Double # (^-) :: Double -> Integer -> Double #
C Double #
Methods toRational :: Double -> Rational #
C Double #
Methods sqrt :: Double -> Double # root :: Integer -> Double -> Double # (^/) :: Double -> Rational -> Double #
C Double #
Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # logBase :: Double -> Double -> Double # (**) :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double #
C Double #
Methods splitFraction :: C b => Double -> (b, Double) # fraction :: Double -> Double # ceiling :: C b => Double -> b # floor :: C b => Double -> b # truncate :: C b => Double -> b # round :: C b => Double -> b #
C Double #

C Double #
Methods atan2 :: Double -> Double -> Double #
C Double #
Methods radix :: Double -> Integer # digits :: Double -> Int # range :: Double -> (Int, Int) # decode :: Double -> (Integer, Int) # encode :: Integer -> Int -> Double # exponent :: Double -> Int # significand :: Double -> Double # scale :: Int -> Double -> Double # isNaN :: Double -> Bool # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # isIEEE :: Double -> Bool #
Power Double #
Methods power :: Rational -> T Double -> T Double #
C Double Double #
Methods (*>) :: Double -> Double -> Double #
C Double Double #

C Double Double #
Methods basis :: Double -> [Double] # flatten :: Double -> [Double] # dimension :: Double -> Double -> Int #
C Double Double #
Methods toScalar :: Double -> Double # toMaybeScalar :: Double -> Maybe Double # fromScalar :: Double -> Double #
C Double Double #
Methods norm :: Double -> Double #
C Double Double #
Methods norm :: Double -> Double #
C Double Double #
Methods norm :: Double -> Double #
Sqr Double Double #
Methods normSqr :: Double -> Double #
Generic1 k (URec k Double)
Associated Types type Rep1 (URec k Double) (f :: URec k Double -> ) :: k -> # Methods from1 :: f a -> Rep1 (URec k Double) f a # to1 :: Rep1 (URec k Double) f a -> f a #
Functor (URec * Double)
Methods fmap :: (a -> b) -> URec * Double a -> URec * Double b # (<$) :: a -> URec * Double b -> URec * Double a #
Foldable (URec * Double)
Methods fold :: Monoid m => URec * Double m -> m # foldMap :: Monoid m => (a -> m) -> URec * Double a -> m # foldr :: (a -> b -> b) -> b -> URec * Double a -> b # foldr' :: (a -> b -> b) -> b -> URec * Double a -> b # foldl :: (b -> a -> b) -> b -> URec * Double a -> b # foldl' :: (b -> a -> b) -> b -> URec * Double a -> b # foldr1 :: (a -> a -> a) -> URec * Double a -> a # foldl1 :: (a -> a -> a) -> URec * Double a -> a # toList :: URec * Double a -> [a] # null :: URec * Double a -> Bool # length :: URec * Double a -> Int # elem :: Eq a => a -> URec * Double a -> Bool # maximum :: Ord a => URec * Double a -> a # minimum :: Ord a => URec * Double a -> a # sum :: Num a => URec * Double a -> a # product :: Num a => URec * Double a -> a #
Traversable (URec * Double)
Methods traverse :: Applicative f => (a -> f b) -> URec * Double a -> f (URec * Double b) # sequenceA :: Applicative f => URec * Double (f a) -> f (URec * Double a) # mapM :: Monad m => (a -> m b) -> URec * Double a -> m (URec * Double b) # sequence :: Monad m => URec * Double (m a) -> m (URec * Double a) #
Eq (URec k Double p)
Methods (==) :: URec k Double p -> URec k Double p -> Bool # (/=) :: URec k Double p -> URec k Double p -> Bool #
Ord (URec k Double p)
Methods compare :: URec k Double p -> URec k Double p -> Ordering # (<) :: URec k Double p -> URec k Double p -> Bool # (<=) :: URec k Double p -> URec k Double p -> Bool # (>) :: URec k Double p -> URec k Double p -> Bool # (>=) :: URec k Double p -> URec k Double p -> Bool # max :: URec k Double p -> URec k Double p -> URec k Double p # min :: URec k Double p -> URec k Double p -> URec k Double p #
Show (URec k Double p)
Methods showsPrec :: Int -> URec k Double p -> ShowS # show :: URec k Double p -> String # showList :: [URec k Double p] -> ShowS #
Generic (URec k Double p)
Associated Types type Rep (URec k Double p) :: * -> * # Methods from :: URec k Double p -> Rep (URec k Double p) x # to :: Rep (URec k Double p) x -> URec k Double p #
data URec k Double	Used for marking occurrences of `Double#` Since: 4.9.0.0
data URec k Double = UDouble { uDouble# :: Double# }
type Rep1 k (URec k Double)
type Rep1 k (URec k Double) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UDouble" PrefixI True) (S1 k (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble k)))
type Rep (URec k Double p)
type Rep (URec k Double p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UDouble" PrefixI True) (S1 * (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble *)))

(*>) :: C a v => a -> v -> v infixr 7 #

scale a vector by a scalar