NumInstances-1.4: Instances of numeric classes for functions and tuples

Copyright | (c) Conal Elliott 2008-2013
License | BSD3
Maintainer | conal@conal.net
Stability | experimental
Safe Haskell | Safe
Language | Haskell98

Data.NumInstances.Tuple

Contents

- Orphan instances

Description

Number class instances for tuples

# Orphan instances

(Floating a, Floating b) => Floating (a, b) Source # |

Methods

pi :: (a, b) #

exp :: (a, b) -> (a, b) #

log :: (a, b) -> (a, b) #

sqrt :: (a, b) -> (a, b) #

(**) :: (a, b) -> (a, b) -> (a, b) #

logBase :: (a, b) -> (a, b) -> (a, b) #

sin :: (a, b) -> (a, b) #

cos :: (a, b) -> (a, b) #

tan :: (a, b) -> (a, b) #

asin :: (a, b) -> (a, b) #

acos :: (a, b) -> (a, b) #

atan :: (a, b) -> (a, b) #

sinh :: (a, b) -> (a, b) #

cosh :: (a, b) -> (a, b) #

tanh :: (a, b) -> (a, b) #

asinh :: (a, b) -> (a, b) #

acosh :: (a, b) -> (a, b) #

atanh :: (a, b) -> (a, b) #

log1p :: (a, b) -> (a, b) #

expm1 :: (a, b) -> (a, b) #

log1pexp :: (a, b) -> (a, b) #

log1mexp :: (a, b) -> (a, b) #

(Fractional a, Fractional b) => Fractional (a, b) Source # |
Methods (/) :: (a, b) -> (a, b) -> (a, b) # recip :: (a, b) -> (a, b) # fromRational :: Rational -> (a, b) #
(Num a, Num b) => Num (a, b) Source # |
Methods (+) :: (a, b) -> (a, b) -> (a, b) # (-) :: (a, b) -> (a, b) -> (a, b) # (*) :: (a, b) -> (a, b) -> (a, b) # negate :: (a, b) -> (a, b) # abs :: (a, b) -> (a, b) # signum :: (a, b) -> (a, b) # fromInteger :: Integer -> (a, b) #
(Floating a, Floating b, Floating c) => Floating (a, b, c) Source # |

Methods

pi :: (a, b, c) #

exp :: (a, b, c) -> (a, b, c) #

log :: (a, b, c) -> (a, b, c) #

sqrt :: (a, b, c) -> (a, b, c) #

(**) :: (a, b, c) -> (a, b, c) -> (a, b, c) #

logBase :: (a, b, c) -> (a, b, c) -> (a, b, c) #

sin :: (a, b, c) -> (a, b, c) #

cos :: (a, b, c) -> (a, b, c) #

tan :: (a, b, c) -> (a, b, c) #

asin :: (a, b, c) -> (a, b, c) #

acos :: (a, b, c) -> (a, b, c) #

atan :: (a, b, c) -> (a, b, c) #

sinh :: (a, b, c) -> (a, b, c) #

cosh :: (a, b, c) -> (a, b, c) #

tanh :: (a, b, c) -> (a, b, c) #

asinh :: (a, b, c) -> (a, b, c) #

acosh :: (a, b, c) -> (a, b, c) #

atanh :: (a, b, c) -> (a, b, c) #

log1p :: (a, b, c) -> (a, b, c) #

expm1 :: (a, b, c) -> (a, b, c) #

log1pexp :: (a, b, c) -> (a, b, c) #

log1mexp :: (a, b, c) -> (a, b, c) #

(Fractional a, Fractional b, Fractional c) => Fractional (a, b, c) Source # |
Methods (/) :: (a, b, c) -> (a, b, c) -> (a, b, c) # recip :: (a, b, c) -> (a, b, c) # fromRational :: Rational -> (a, b, c) #
(Num a, Num b, Num c) => Num (a, b, c) Source # |
Methods (+) :: (a, b, c) -> (a, b, c) -> (a, b, c) # (-) :: (a, b, c) -> (a, b, c) -> (a, b, c) # (*) :: (a, b, c) -> (a, b, c) -> (a, b, c) # negate :: (a, b, c) -> (a, b, c) # abs :: (a, b, c) -> (a, b, c) # signum :: (a, b, c) -> (a, b, c) # fromInteger :: Integer -> (a, b, c) #
(Floating a, Floating b, Floating c, Floating d) => Floating (a, b, c, d) Source # |

Methods

pi :: (a, b, c, d) #

exp :: (a, b, c, d) -> (a, b, c, d) #

log :: (a, b, c, d) -> (a, b, c, d) #

sqrt :: (a, b, c, d) -> (a, b, c, d) #

(**) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #

logBase :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #

sin :: (a, b, c, d) -> (a, b, c, d) #

cos :: (a, b, c, d) -> (a, b, c, d) #

tan :: (a, b, c, d) -> (a, b, c, d) #

asin :: (a, b, c, d) -> (a, b, c, d) #

acos :: (a, b, c, d) -> (a, b, c, d) #

atan :: (a, b, c, d) -> (a, b, c, d) #

sinh :: (a, b, c, d) -> (a, b, c, d) #

cosh :: (a, b, c, d) -> (a, b, c, d) #

tanh :: (a, b, c, d) -> (a, b, c, d) #

asinh :: (a, b, c, d) -> (a, b, c, d) #

acosh :: (a, b, c, d) -> (a, b, c, d) #

atanh :: (a, b, c, d) -> (a, b, c, d) #

log1p :: (a, b, c, d) -> (a, b, c, d) #

expm1 :: (a, b, c, d) -> (a, b, c, d) #

log1pexp :: (a, b, c, d) -> (a, b, c, d) #

log1mexp :: (a, b, c, d) -> (a, b, c, d) #

(Fractional a, Fractional b, Fractional c, Fractional d) => Fractional (a, b, c, d) Source # |
Methods (/) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # recip :: (a, b, c, d) -> (a, b, c, d) # fromRational :: Rational -> (a, b, c, d) #
(Num a, Num b, Num c, Num d) => Num (a, b, c, d) Source # |
Methods (+) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # (-) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # (*) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # negate :: (a, b, c, d) -> (a, b, c, d) # abs :: (a, b, c, d) -> (a, b, c, d) # signum :: (a, b, c, d) -> (a, b, c, d) # fromInteger :: Integer -> (a, b, c, d) #
(Floating a, Floating b, Floating c, Floating d, Floating e) => Floating (a, b, c, d, e) Source # |

Methods

pi :: (a, b, c, d, e) #

exp :: (a, b, c, d, e) -> (a, b, c, d, e) #

log :: (a, b, c, d, e) -> (a, b, c, d, e) #

sqrt :: (a, b, c, d, e) -> (a, b, c, d, e) #

(**) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) #

logBase :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) #

sin :: (a, b, c, d, e) -> (a, b, c, d, e) #

cos :: (a, b, c, d, e) -> (a, b, c, d, e) #

tan :: (a, b, c, d, e) -> (a, b, c, d, e) #

asin :: (a, b, c, d, e) -> (a, b, c, d, e) #

acos :: (a, b, c, d, e) -> (a, b, c, d, e) #

atan :: (a, b, c, d, e) -> (a, b, c, d, e) #

sinh :: (a, b, c, d, e) -> (a, b, c, d, e) #

cosh :: (a, b, c, d, e) -> (a, b, c, d, e) #

tanh :: (a, b, c, d, e) -> (a, b, c, d, e) #

asinh :: (a, b, c, d, e) -> (a, b, c, d, e) #

acosh :: (a, b, c, d, e) -> (a, b, c, d, e) #

atanh :: (a, b, c, d, e) -> (a, b, c, d, e) #

log1p :: (a, b, c, d, e) -> (a, b, c, d, e) #

expm1 :: (a, b, c, d, e) -> (a, b, c, d, e) #

log1pexp :: (a, b, c, d, e) -> (a, b, c, d, e) #

log1mexp :: (a, b, c, d, e) -> (a, b, c, d, e) #

(Fractional a, Fractional b, Fractional c, Fractional d, Fractional e) => Fractional (a, b, c, d, e) Source # |
Methods (/) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # recip :: (a, b, c, d, e) -> (a, b, c, d, e) # fromRational :: Rational -> (a, b, c, d, e) #
(Num a, Num b, Num c, Num d, Num e) => Num (a, b, c, d, e) Source # |
Methods (+) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # (-) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # (*) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # negate :: (a, b, c, d, e) -> (a, b, c, d, e) # abs :: (a, b, c, d, e) -> (a, b, c, d, e) # signum :: (a, b, c, d, e) -> (a, b, c, d, e) # fromInteger :: Integer -> (a, b, c, d, e) #
(Floating a, Floating b, Floating c, Floating d, Floating e, Floating f) => Floating (a, b, c, d, e, f) Source # |

Methods

pi :: (a, b, c, d, e, f) #

exp :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

log :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

sqrt :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

(**) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

logBase :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

sin :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

cos :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

tan :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

asin :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

acos :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

atan :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

sinh :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

cosh :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

tanh :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

asinh :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

acosh :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

atanh :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

log1p :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

expm1 :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

log1pexp :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

log1mexp :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

(Fractional a, Fractional b, Fractional c, Fractional d, Fractional e, Fractional f) => Fractional (a, b, c, d, e, f) Source # |
Methods (/) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # recip :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) # fromRational :: Rational -> (a, b, c, d, e, f) #
(Num a, Num b, Num c, Num d, Num e, Num f) => Num (a, b, c, d, e, f) Source # |

Methods

(+) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

(-) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

(*) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

negate :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

abs :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

signum :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

fromInteger :: Integer -> (a, b, c, d, e, f) #

(Floating a, Floating b, Floating c, Floating d, Floating e, Floating f, Floating g) => Floating (a, b, c, d, e, f, g) Source # |

Methods

pi :: (a, b, c, d, e, f, g) #

exp :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

log :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

sqrt :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

(**) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

logBase :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

sin :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

cos :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

tan :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

asin :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

acos :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

atan :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

sinh :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

cosh :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

tanh :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

asinh :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

acosh :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

atanh :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

log1p :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

expm1 :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

log1pexp :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

log1mexp :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

(Fractional a, Fractional b, Fractional c, Fractional d, Fractional e, Fractional f, Fractional g) => Fractional (a, b, c, d, e, f, g) Source # |
Methods (/) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # recip :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # fromRational :: Rational -> (a, b, c, d, e, f, g) #
(Num a, Num b, Num c, Num d, Num e, Num f, Num g) => Num (a, b, c, d, e, f, g) Source # |

Methods

(+) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

(-) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

(*) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

negate :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

abs :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

signum :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

fromInteger :: Integer -> (a, b, c, d, e, f, g) #