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

Copyright(c) Conal Elliott 2008-2013
LicenseBSD3
Maintainerconal@conal.net
Stabilityexperimental
Safe HaskellSafe
LanguageHaskell98

Data.NumInstances.Tuple

Contents

Description

Number class instances for tuples

Orphan instances

(Floating a, Floating b) => Floating (a, b) # 
Instance details

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) # 
Instance details

Methods

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

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

fromRational :: Rational -> (a, b) #

(Num a, Num b) => Num (a, b) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) # 
Instance details

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) #