Documentation

Methods

showsDimPrec :: Int -> ShowS Source #

showDim :: String Source #

prettysDimPrec :: Int -> ShowS Source #

prettyDim :: String Source #

Methods

pi :: Mass a #

exp :: Mass a -> Mass a #

log :: Mass a -> Mass a #

sqrt :: Mass a -> Mass a #

(**) :: Mass a -> Mass a -> Mass a #

logBase :: Mass a -> Mass a -> Mass a #

sin :: Mass a -> Mass a #

cos :: Mass a -> Mass a #

tan :: Mass a -> Mass a #

asin :: Mass a -> Mass a #

acos :: Mass a -> Mass a #

atan :: Mass a -> Mass a #

sinh :: Mass a -> Mass a #

cosh :: Mass a -> Mass a #

tanh :: Mass a -> Mass a #

asinh :: Mass a -> Mass a #

acosh :: Mass a -> Mass a #

atanh :: Mass a -> Mass a #

log1p :: Mass a -> Mass a #

expm1 :: Mass a -> Mass a #

log1pexp :: Mass a -> Mass a #

log1mexp :: Mass a -> Mass a #

Methods

floatRadix :: Mass a -> Integer #

floatDigits :: Mass a -> Int #

floatRange :: Mass a -> (Int, Int) #

decodeFloat :: Mass a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Mass a #

exponent :: Mass a -> Int #

significand :: Mass a -> Mass a #

scaleFloat :: Int -> Mass a -> Mass a #

isNaN :: Mass a -> Bool #

isInfinite :: Mass a -> Bool #

isDenormalized :: Mass a -> Bool #

isNegativeZero :: Mass a -> Bool #

isIEEE :: Mass a -> Bool #

atan2 :: Mass a -> Mass a -> Mass a #

Methods

(+) :: Mass a -> Mass a -> Mass a #

(-) :: Mass a -> Mass a -> Mass a #

(*) :: Mass a -> Mass a -> Mass a #

negate :: Mass a -> Mass a #

abs :: Mass a -> Mass a #

signum :: Mass a -> Mass a #

fromInteger :: Integer -> Mass a #

Methods

(/) :: Mass a -> Mass a -> Mass a #

recip :: Mass a -> Mass a #

fromRational :: Rational -> Mass a #

Methods

toRational :: Mass a -> Rational #

Methods

properFraction :: Integral b => Mass a -> (b, Mass a) #

truncate :: Integral b => Mass a -> b #

round :: Integral b => Mass a -> b #

ceiling :: Integral b => Mass a -> b #

floor :: Integral b => Mass a -> b #

Methods

showsPrec :: Int -> Mass a -> ShowS #

show :: Mass a -> String #

showList :: [Mass a] -> ShowS #

Methods

(==) :: Mass a -> Mass a -> Bool #

(/=) :: Mass a -> Mass a -> Bool #

Methods

compare :: Mass a -> Mass a -> Ordering #

(<) :: Mass a -> Mass a -> Bool #

(<=) :: Mass a -> Mass a -> Bool #

(>) :: Mass a -> Mass a -> Bool #

(>=) :: Mass a -> Mass a -> Bool #

max :: Mass a -> Mass a -> Mass a #

min :: Mass a -> Mass a -> Mass a #

Methods

showsUnitPrec :: Int -> ShowS Source #

showUnit :: String Source #

prettysUnitPrec :: Int -> ShowS Source #

prettyUnit :: String Source #

Methods

factor :: a Source #

Methods

toBaseUnit :: Gram a -> BaseUnitOf Gram a Source #

fromBaseUnit :: BaseUnitOf Gram a -> Gram a Source #

Methods

pi :: Gram a #

exp :: Gram a -> Gram a #

log :: Gram a -> Gram a #

sqrt :: Gram a -> Gram a #

(**) :: Gram a -> Gram a -> Gram a #

logBase :: Gram a -> Gram a -> Gram a #

sin :: Gram a -> Gram a #

cos :: Gram a -> Gram a #

tan :: Gram a -> Gram a #

asin :: Gram a -> Gram a #

acos :: Gram a -> Gram a #

atan :: Gram a -> Gram a #

sinh :: Gram a -> Gram a #

cosh :: Gram a -> Gram a #

tanh :: Gram a -> Gram a #

asinh :: Gram a -> Gram a #

acosh :: Gram a -> Gram a #

atanh :: Gram a -> Gram a #

log1p :: Gram a -> Gram a #

expm1 :: Gram a -> Gram a #

log1pexp :: Gram a -> Gram a #

log1mexp :: Gram a -> Gram a #

Methods

floatRadix :: Gram a -> Integer #

floatDigits :: Gram a -> Int #

floatRange :: Gram a -> (Int, Int) #

decodeFloat :: Gram a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Gram a #

exponent :: Gram a -> Int #

significand :: Gram a -> Gram a #

scaleFloat :: Int -> Gram a -> Gram a #

isNaN :: Gram a -> Bool #

isInfinite :: Gram a -> Bool #

isDenormalized :: Gram a -> Bool #

isNegativeZero :: Gram a -> Bool #

isIEEE :: Gram a -> Bool #

atan2 :: Gram a -> Gram a -> Gram a #

Methods

(+) :: Gram a -> Gram a -> Gram a #

(-) :: Gram a -> Gram a -> Gram a #

(*) :: Gram a -> Gram a -> Gram a #

negate :: Gram a -> Gram a #

abs :: Gram a -> Gram a #

signum :: Gram a -> Gram a #

fromInteger :: Integer -> Gram a #

Methods

(/) :: Gram a -> Gram a -> Gram a #

recip :: Gram a -> Gram a #

fromRational :: Rational -> Gram a #

Methods

toRational :: Gram a -> Rational #

Methods

properFraction :: Integral b => Gram a -> (b, Gram a) #

truncate :: Integral b => Gram a -> b #

round :: Integral b => Gram a -> b #

ceiling :: Integral b => Gram a -> b #

floor :: Integral b => Gram a -> b #

Methods

showsPrec :: Int -> Gram a -> ShowS #

show :: Gram a -> String #

showList :: [Gram a] -> ShowS #

Methods

(==) :: Gram a -> Gram a -> Bool #

(/=) :: Gram a -> Gram a -> Bool #

Methods

compare :: Gram a -> Gram a -> Ordering #

(<) :: Gram a -> Gram a -> Bool #

(<=) :: Gram a -> Gram a -> Bool #

(>) :: Gram a -> Gram a -> Bool #

(>=) :: Gram a -> Gram a -> Bool #

max :: Gram a -> Gram a -> Gram a #

min :: Gram a -> Gram a -> Gram a #

Methods

showsDimPrec :: Int -> ShowS Source #

showDim :: String Source #

prettysDimPrec :: Int -> ShowS Source #

prettyDim :: String Source #

Methods

pi :: Length a #

exp :: Length a -> Length a #

log :: Length a -> Length a #

sqrt :: Length a -> Length a #

(**) :: Length a -> Length a -> Length a #

logBase :: Length a -> Length a -> Length a #

sin :: Length a -> Length a #

cos :: Length a -> Length a #

tan :: Length a -> Length a #

asin :: Length a -> Length a #

acos :: Length a -> Length a #

atan :: Length a -> Length a #

sinh :: Length a -> Length a #

cosh :: Length a -> Length a #

tanh :: Length a -> Length a #

asinh :: Length a -> Length a #

acosh :: Length a -> Length a #

atanh :: Length a -> Length a #

log1p :: Length a -> Length a #

expm1 :: Length a -> Length a #

log1pexp :: Length a -> Length a #

log1mexp :: Length a -> Length a #

Methods

floatRadix :: Length a -> Integer #

floatDigits :: Length a -> Int #

floatRange :: Length a -> (Int, Int) #

decodeFloat :: Length a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Length a #

exponent :: Length a -> Int #

significand :: Length a -> Length a #

scaleFloat :: Int -> Length a -> Length a #

isNaN :: Length a -> Bool #

isInfinite :: Length a -> Bool #

isDenormalized :: Length a -> Bool #

isNegativeZero :: Length a -> Bool #

isIEEE :: Length a -> Bool #

atan2 :: Length a -> Length a -> Length a #

Methods

(+) :: Length a -> Length a -> Length a #

(-) :: Length a -> Length a -> Length a #

(*) :: Length a -> Length a -> Length a #

negate :: Length a -> Length a #

abs :: Length a -> Length a #

signum :: Length a -> Length a #

fromInteger :: Integer -> Length a #

Methods

(/) :: Length a -> Length a -> Length a #

recip :: Length a -> Length a #

fromRational :: Rational -> Length a #

Methods

toRational :: Length a -> Rational #

Methods

properFraction :: Integral b => Length a -> (b, Length a) #

truncate :: Integral b => Length a -> b #

round :: Integral b => Length a -> b #

ceiling :: Integral b => Length a -> b #

floor :: Integral b => Length a -> b #

Methods

showsPrec :: Int -> Length a -> ShowS #

show :: Length a -> String #

showList :: [Length a] -> ShowS #

Methods

(==) :: Length a -> Length a -> Bool #

(/=) :: Length a -> Length a -> Bool #

Methods

compare :: Length a -> Length a -> Ordering #

(<) :: Length a -> Length a -> Bool #

(<=) :: Length a -> Length a -> Bool #

(>) :: Length a -> Length a -> Bool #

(>=) :: Length a -> Length a -> Bool #

max :: Length a -> Length a -> Length a #

min :: Length a -> Length a -> Length a #

Methods

showsUnitPrec :: Int -> ShowS Source #

showUnit :: String Source #

prettysUnitPrec :: Int -> ShowS Source #

prettyUnit :: String Source #

Methods

factor :: a Source #

Methods

toBaseUnit :: Meter a -> BaseUnitOf Meter a Source #

fromBaseUnit :: BaseUnitOf Meter a -> Meter a Source #

Methods

pi :: Meter a #

exp :: Meter a -> Meter a #

log :: Meter a -> Meter a #

sqrt :: Meter a -> Meter a #

(**) :: Meter a -> Meter a -> Meter a #

logBase :: Meter a -> Meter a -> Meter a #

sin :: Meter a -> Meter a #

cos :: Meter a -> Meter a #

tan :: Meter a -> Meter a #

asin :: Meter a -> Meter a #

acos :: Meter a -> Meter a #

atan :: Meter a -> Meter a #

sinh :: Meter a -> Meter a #

cosh :: Meter a -> Meter a #

tanh :: Meter a -> Meter a #

asinh :: Meter a -> Meter a #

acosh :: Meter a -> Meter a #

atanh :: Meter a -> Meter a #

log1p :: Meter a -> Meter a #

expm1 :: Meter a -> Meter a #

log1pexp :: Meter a -> Meter a #

log1mexp :: Meter a -> Meter a #

Methods

floatRadix :: Meter a -> Integer #

floatDigits :: Meter a -> Int #

floatRange :: Meter a -> (Int, Int) #

decodeFloat :: Meter a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Meter a #

exponent :: Meter a -> Int #

significand :: Meter a -> Meter a #

scaleFloat :: Int -> Meter a -> Meter a #

isNaN :: Meter a -> Bool #

isInfinite :: Meter a -> Bool #

isDenormalized :: Meter a -> Bool #

isNegativeZero :: Meter a -> Bool #

isIEEE :: Meter a -> Bool #

atan2 :: Meter a -> Meter a -> Meter a #

Methods

(+) :: Meter a -> Meter a -> Meter a #

(-) :: Meter a -> Meter a -> Meter a #

(*) :: Meter a -> Meter a -> Meter a #

negate :: Meter a -> Meter a #

abs :: Meter a -> Meter a #

signum :: Meter a -> Meter a #

fromInteger :: Integer -> Meter a #

Methods

(/) :: Meter a -> Meter a -> Meter a #

recip :: Meter a -> Meter a #

fromRational :: Rational -> Meter a #

Methods

toRational :: Meter a -> Rational #

Methods

properFraction :: Integral b => Meter a -> (b, Meter a) #

truncate :: Integral b => Meter a -> b #

round :: Integral b => Meter a -> b #

ceiling :: Integral b => Meter a -> b #

floor :: Integral b => Meter a -> b #

Methods

showsPrec :: Int -> Meter a -> ShowS #

show :: Meter a -> String #

showList :: [Meter a] -> ShowS #

Methods

(==) :: Meter a -> Meter a -> Bool #

(/=) :: Meter a -> Meter a -> Bool #

Methods

compare :: Meter a -> Meter a -> Ordering #

(<) :: Meter a -> Meter a -> Bool #

(<=) :: Meter a -> Meter a -> Bool #

(>) :: Meter a -> Meter a -> Bool #

(>=) :: Meter a -> Meter a -> Bool #

max :: Meter a -> Meter a -> Meter a #

min :: Meter a -> Meter a -> Meter a #

Methods

showsDimPrec :: Int -> ShowS Source #

showDim :: String Source #

prettysDimPrec :: Int -> ShowS Source #

prettyDim :: String Source #

Methods

pi :: Time a #

exp :: Time a -> Time a #

log :: Time a -> Time a #

sqrt :: Time a -> Time a #

(**) :: Time a -> Time a -> Time a #

logBase :: Time a -> Time a -> Time a #

sin :: Time a -> Time a #

cos :: Time a -> Time a #

tan :: Time a -> Time a #

asin :: Time a -> Time a #

acos :: Time a -> Time a #

atan :: Time a -> Time a #

sinh :: Time a -> Time a #

cosh :: Time a -> Time a #

tanh :: Time a -> Time a #

asinh :: Time a -> Time a #

acosh :: Time a -> Time a #

atanh :: Time a -> Time a #

log1p :: Time a -> Time a #

expm1 :: Time a -> Time a #

log1pexp :: Time a -> Time a #

log1mexp :: Time a -> Time a #

Methods

floatRadix :: Time a -> Integer #

floatDigits :: Time a -> Int #

floatRange :: Time a -> (Int, Int) #

decodeFloat :: Time a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Time a #

exponent :: Time a -> Int #

significand :: Time a -> Time a #

scaleFloat :: Int -> Time a -> Time a #

isNaN :: Time a -> Bool #

isInfinite :: Time a -> Bool #

isDenormalized :: Time a -> Bool #

isNegativeZero :: Time a -> Bool #

isIEEE :: Time a -> Bool #

atan2 :: Time a -> Time a -> Time a #

Methods

(+) :: Time a -> Time a -> Time a #

(-) :: Time a -> Time a -> Time a #

(*) :: Time a -> Time a -> Time a #

negate :: Time a -> Time a #

abs :: Time a -> Time a #

signum :: Time a -> Time a #

fromInteger :: Integer -> Time a #

Methods

(/) :: Time a -> Time a -> Time a #

recip :: Time a -> Time a #

fromRational :: Rational -> Time a #

Methods

toRational :: Time a -> Rational #

Methods

properFraction :: Integral b => Time a -> (b, Time a) #

truncate :: Integral b => Time a -> b #

round :: Integral b => Time a -> b #

ceiling :: Integral b => Time a -> b #

floor :: Integral b => Time a -> b #

Methods

showsPrec :: Int -> Time a -> ShowS #

show :: Time a -> String #

showList :: [Time a] -> ShowS #

Methods

(==) :: Time a -> Time a -> Bool #

(/=) :: Time a -> Time a -> Bool #

Methods

compare :: Time a -> Time a -> Ordering #

(<) :: Time a -> Time a -> Bool #

(<=) :: Time a -> Time a -> Bool #

(>) :: Time a -> Time a -> Bool #

(>=) :: Time a -> Time a -> Bool #

max :: Time a -> Time a -> Time a #

min :: Time a -> Time a -> Time a #

Methods

showsUnitPrec :: Int -> ShowS Source #

showUnit :: String Source #

prettysUnitPrec :: Int -> ShowS Source #

prettyUnit :: String Source #

Methods

factor :: a Source #

Methods

toBaseUnit :: Second a -> BaseUnitOf Second a Source #

fromBaseUnit :: BaseUnitOf Second a -> Second a Source #

Methods

pi :: Second a #

exp :: Second a -> Second a #

log :: Second a -> Second a #

sqrt :: Second a -> Second a #

(**) :: Second a -> Second a -> Second a #

logBase :: Second a -> Second a -> Second a #

sin :: Second a -> Second a #

cos :: Second a -> Second a #

tan :: Second a -> Second a #

asin :: Second a -> Second a #

acos :: Second a -> Second a #

atan :: Second a -> Second a #

sinh :: Second a -> Second a #

cosh :: Second a -> Second a #

tanh :: Second a -> Second a #

asinh :: Second a -> Second a #

acosh :: Second a -> Second a #

atanh :: Second a -> Second a #

log1p :: Second a -> Second a #

expm1 :: Second a -> Second a #

log1pexp :: Second a -> Second a #

log1mexp :: Second a -> Second a #

Methods

floatRadix :: Second a -> Integer #

floatDigits :: Second a -> Int #

floatRange :: Second a -> (Int, Int) #

decodeFloat :: Second a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Second a #

exponent :: Second a -> Int #

significand :: Second a -> Second a #

scaleFloat :: Int -> Second a -> Second a #

isNaN :: Second a -> Bool #

isInfinite :: Second a -> Bool #

isDenormalized :: Second a -> Bool #

isNegativeZero :: Second a -> Bool #

isIEEE :: Second a -> Bool #

atan2 :: Second a -> Second a -> Second a #

Methods

(+) :: Second a -> Second a -> Second a #

(-) :: Second a -> Second a -> Second a #

(*) :: Second a -> Second a -> Second a #

negate :: Second a -> Second a #

abs :: Second a -> Second a #

signum :: Second a -> Second a #

fromInteger :: Integer -> Second a #

Methods

(/) :: Second a -> Second a -> Second a #

recip :: Second a -> Second a #

fromRational :: Rational -> Second a #

Methods

toRational :: Second a -> Rational #

Methods

properFraction :: Integral b => Second a -> (b, Second a) #

truncate :: Integral b => Second a -> b #

round :: Integral b => Second a -> b #

ceiling :: Integral b => Second a -> b #

floor :: Integral b => Second a -> b #

Methods

showsPrec :: Int -> Second a -> ShowS #

show :: Second a -> String #

showList :: [Second a] -> ShowS #

Methods

(==) :: Second a -> Second a -> Bool #

(/=) :: Second a -> Second a -> Bool #

Methods

compare :: Second a -> Second a -> Ordering #

(<) :: Second a -> Second a -> Bool #

(<=) :: Second a -> Second a -> Bool #

(>) :: Second a -> Second a -> Bool #

(>=) :: Second a -> Second a -> Bool #

max :: Second a -> Second a -> Second a #

min :: Second a -> Second a -> Second a #

Methods

showsDimPrec :: Int -> ShowS Source #

showDim :: String Source #

prettysDimPrec :: Int -> ShowS Source #

prettyDim :: String Source #

Methods

pi :: Temperature a #

exp :: Temperature a -> Temperature a #

log :: Temperature a -> Temperature a #

sqrt :: Temperature a -> Temperature a #

(**) :: Temperature a -> Temperature a -> Temperature a #

logBase :: Temperature a -> Temperature a -> Temperature a #

sin :: Temperature a -> Temperature a #

cos :: Temperature a -> Temperature a #

tan :: Temperature a -> Temperature a #

asin :: Temperature a -> Temperature a #

acos :: Temperature a -> Temperature a #

atan :: Temperature a -> Temperature a #

sinh :: Temperature a -> Temperature a #

cosh :: Temperature a -> Temperature a #

tanh :: Temperature a -> Temperature a #

asinh :: Temperature a -> Temperature a #

acosh :: Temperature a -> Temperature a #

atanh :: Temperature a -> Temperature a #

log1p :: Temperature a -> Temperature a #

expm1 :: Temperature a -> Temperature a #

log1pexp :: Temperature a -> Temperature a #

log1mexp :: Temperature a -> Temperature a #

Methods

floatRadix :: Temperature a -> Integer #

floatDigits :: Temperature a -> Int #

floatRange :: Temperature a -> (Int, Int) #

decodeFloat :: Temperature a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Temperature a #

exponent :: Temperature a -> Int #

significand :: Temperature a -> Temperature a #

scaleFloat :: Int -> Temperature a -> Temperature a #

isNaN :: Temperature a -> Bool #

isInfinite :: Temperature a -> Bool #

isDenormalized :: Temperature a -> Bool #

isNegativeZero :: Temperature a -> Bool #

isIEEE :: Temperature a -> Bool #

atan2 :: Temperature a -> Temperature a -> Temperature a #

Methods

(+) :: Temperature a -> Temperature a -> Temperature a #

(-) :: Temperature a -> Temperature a -> Temperature a #

(*) :: Temperature a -> Temperature a -> Temperature a #

negate :: Temperature a -> Temperature a #

abs :: Temperature a -> Temperature a #

signum :: Temperature a -> Temperature a #

fromInteger :: Integer -> Temperature a #

Methods

(/) :: Temperature a -> Temperature a -> Temperature a #

recip :: Temperature a -> Temperature a #

fromRational :: Rational -> Temperature a #

Methods

toRational :: Temperature a -> Rational #

Methods

properFraction :: Integral b => Temperature a -> (b, Temperature a) #

truncate :: Integral b => Temperature a -> b #

round :: Integral b => Temperature a -> b #

ceiling :: Integral b => Temperature a -> b #

floor :: Integral b => Temperature a -> b #

Methods

showsPrec :: Int -> Temperature a -> ShowS #

show :: Temperature a -> String #

showList :: [Temperature a] -> ShowS #

Methods

(==) :: Temperature a -> Temperature a -> Bool #

(/=) :: Temperature a -> Temperature a -> Bool #

Methods

compare :: Temperature a -> Temperature a -> Ordering #

(<) :: Temperature a -> Temperature a -> Bool #

(<=) :: Temperature a -> Temperature a -> Bool #

(>) :: Temperature a -> Temperature a -> Bool #

(>=) :: Temperature a -> Temperature a -> Bool #

max :: Temperature a -> Temperature a -> Temperature a #

min :: Temperature a -> Temperature a -> Temperature a #

Methods

showsUnitPrec :: Int -> ShowS Source #

showUnit :: String Source #

prettysUnitPrec :: Int -> ShowS Source #

prettyUnit :: String Source #

Methods

factor :: a Source #

Methods

toBaseUnit :: Kelvin a -> BaseUnitOf Kelvin a Source #

fromBaseUnit :: BaseUnitOf Kelvin a -> Kelvin a Source #

Methods

pi :: Kelvin a #

exp :: Kelvin a -> Kelvin a #

log :: Kelvin a -> Kelvin a #

sqrt :: Kelvin a -> Kelvin a #

(**) :: Kelvin a -> Kelvin a -> Kelvin a #

logBase :: Kelvin a -> Kelvin a -> Kelvin a #

sin :: Kelvin a -> Kelvin a #

cos :: Kelvin a -> Kelvin a #

tan :: Kelvin a -> Kelvin a #

asin :: Kelvin a -> Kelvin a #

acos :: Kelvin a -> Kelvin a #

atan :: Kelvin a -> Kelvin a #

sinh :: Kelvin a -> Kelvin a #

cosh :: Kelvin a -> Kelvin a #

tanh :: Kelvin a -> Kelvin a #

asinh :: Kelvin a -> Kelvin a #

acosh :: Kelvin a -> Kelvin a #

atanh :: Kelvin a -> Kelvin a #

log1p :: Kelvin a -> Kelvin a #

expm1 :: Kelvin a -> Kelvin a #

log1pexp :: Kelvin a -> Kelvin a #

log1mexp :: Kelvin a -> Kelvin a #

Methods

floatRadix :: Kelvin a -> Integer #

floatDigits :: Kelvin a -> Int #

floatRange :: Kelvin a -> (Int, Int) #

decodeFloat :: Kelvin a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Kelvin a #

exponent :: Kelvin a -> Int #

significand :: Kelvin a -> Kelvin a #

scaleFloat :: Int -> Kelvin a -> Kelvin a #

isNaN :: Kelvin a -> Bool #

isInfinite :: Kelvin a -> Bool #

isDenormalized :: Kelvin a -> Bool #

isNegativeZero :: Kelvin a -> Bool #

isIEEE :: Kelvin a -> Bool #

atan2 :: Kelvin a -> Kelvin a -> Kelvin a #

Methods

(+) :: Kelvin a -> Kelvin a -> Kelvin a #

(-) :: Kelvin a -> Kelvin a -> Kelvin a #

(*) :: Kelvin a -> Kelvin a -> Kelvin a #

negate :: Kelvin a -> Kelvin a #

abs :: Kelvin a -> Kelvin a #

signum :: Kelvin a -> Kelvin a #

fromInteger :: Integer -> Kelvin a #

Methods

(/) :: Kelvin a -> Kelvin a -> Kelvin a #

recip :: Kelvin a -> Kelvin a #

fromRational :: Rational -> Kelvin a #

Methods

toRational :: Kelvin a -> Rational #

Methods

properFraction :: Integral b => Kelvin a -> (b, Kelvin a) #

truncate :: Integral b => Kelvin a -> b #

round :: Integral b => Kelvin a -> b #

ceiling :: Integral b => Kelvin a -> b #

floor :: Integral b => Kelvin a -> b #

Methods

showsPrec :: Int -> Kelvin a -> ShowS #

show :: Kelvin a -> String #

showList :: [Kelvin a] -> ShowS #

Methods

(==) :: Kelvin a -> Kelvin a -> Bool #

(/=) :: Kelvin a -> Kelvin a -> Bool #

Methods

compare :: Kelvin a -> Kelvin a -> Ordering #

(<) :: Kelvin a -> Kelvin a -> Bool #

(<=) :: Kelvin a -> Kelvin a -> Bool #

(>) :: Kelvin a -> Kelvin a -> Bool #

(>=) :: Kelvin a -> Kelvin a -> Bool #

max :: Kelvin a -> Kelvin a -> Kelvin a #

min :: Kelvin a -> Kelvin a -> Kelvin a #

Methods

showsDimPrec :: Int -> ShowS Source #

showDim :: String Source #

prettysDimPrec :: Int -> ShowS Source #

prettyDim :: String Source #

Methods

pi :: AmountOfSubstance a #

exp :: AmountOfSubstance a -> AmountOfSubstance a #

log :: AmountOfSubstance a -> AmountOfSubstance a #

sqrt :: AmountOfSubstance a -> AmountOfSubstance a #

(**) :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

logBase :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

sin :: AmountOfSubstance a -> AmountOfSubstance a #

cos :: AmountOfSubstance a -> AmountOfSubstance a #

tan :: AmountOfSubstance a -> AmountOfSubstance a #

asin :: AmountOfSubstance a -> AmountOfSubstance a #

acos :: AmountOfSubstance a -> AmountOfSubstance a #

atan :: AmountOfSubstance a -> AmountOfSubstance a #

sinh :: AmountOfSubstance a -> AmountOfSubstance a #

cosh :: AmountOfSubstance a -> AmountOfSubstance a #

tanh :: AmountOfSubstance a -> AmountOfSubstance a #

asinh :: AmountOfSubstance a -> AmountOfSubstance a #

acosh :: AmountOfSubstance a -> AmountOfSubstance a #

atanh :: AmountOfSubstance a -> AmountOfSubstance a #

log1p :: AmountOfSubstance a -> AmountOfSubstance a #

expm1 :: AmountOfSubstance a -> AmountOfSubstance a #

log1pexp :: AmountOfSubstance a -> AmountOfSubstance a #

log1mexp :: AmountOfSubstance a -> AmountOfSubstance a #

Methods

floatRadix :: AmountOfSubstance a -> Integer #

floatDigits :: AmountOfSubstance a -> Int #

floatRange :: AmountOfSubstance a -> (Int, Int) #

decodeFloat :: AmountOfSubstance a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> AmountOfSubstance a #

exponent :: AmountOfSubstance a -> Int #

significand :: AmountOfSubstance a -> AmountOfSubstance a #

scaleFloat :: Int -> AmountOfSubstance a -> AmountOfSubstance a #

isNaN :: AmountOfSubstance a -> Bool #

isInfinite :: AmountOfSubstance a -> Bool #

isDenormalized :: AmountOfSubstance a -> Bool #

isNegativeZero :: AmountOfSubstance a -> Bool #

isIEEE :: AmountOfSubstance a -> Bool #

atan2 :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

Methods

(+) :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

(-) :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

(*) :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

negate :: AmountOfSubstance a -> AmountOfSubstance a #

abs :: AmountOfSubstance a -> AmountOfSubstance a #

signum :: AmountOfSubstance a -> AmountOfSubstance a #

fromInteger :: Integer -> AmountOfSubstance a #

Methods

(/) :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

recip :: AmountOfSubstance a -> AmountOfSubstance a #

fromRational :: Rational -> AmountOfSubstance a #

Methods

toRational :: AmountOfSubstance a -> Rational #

Methods

properFraction :: Integral b => AmountOfSubstance a -> (b, AmountOfSubstance a) #

truncate :: Integral b => AmountOfSubstance a -> b #

round :: Integral b => AmountOfSubstance a -> b #

ceiling :: Integral b => AmountOfSubstance a -> b #

floor :: Integral b => AmountOfSubstance a -> b #

Methods

showsPrec :: Int -> AmountOfSubstance a -> ShowS #

show :: AmountOfSubstance a -> String #

showList :: [AmountOfSubstance a] -> ShowS #

Methods

(==) :: AmountOfSubstance a -> AmountOfSubstance a -> Bool #

(/=) :: AmountOfSubstance a -> AmountOfSubstance a -> Bool #

Methods

compare :: AmountOfSubstance a -> AmountOfSubstance a -> Ordering #

(<) :: AmountOfSubstance a -> AmountOfSubstance a -> Bool #

(<=) :: AmountOfSubstance a -> AmountOfSubstance a -> Bool #

(>) :: AmountOfSubstance a -> AmountOfSubstance a -> Bool #

(>=) :: AmountOfSubstance a -> AmountOfSubstance a -> Bool #

max :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

min :: AmountOfSubstance a -> AmountOfSubstance a -> AmountOfSubstance a #

Methods

showsUnitPrec :: Int -> ShowS Source #

showUnit :: String Source #

prettysUnitPrec :: Int -> ShowS Source #

prettyUnit :: String Source #

Methods

factor :: a Source #

Methods

toBaseUnit :: Mole a -> BaseUnitOf Mole a Source #

fromBaseUnit :: BaseUnitOf Mole a -> Mole a Source #

Methods

pi :: Mole a #

exp :: Mole a -> Mole a #

log :: Mole a -> Mole a #

sqrt :: Mole a -> Mole a #

(**) :: Mole a -> Mole a -> Mole a #

logBase :: Mole a -> Mole a -> Mole a #

sin :: Mole a -> Mole a #

cos :: Mole a -> Mole a #

tan :: Mole a -> Mole a #

asin :: Mole a -> Mole a #

acos :: Mole a -> Mole a #

atan :: Mole a -> Mole a #

sinh :: Mole a -> Mole a #

cosh :: Mole a -> Mole a #

tanh :: Mole a -> Mole a #

asinh :: Mole a -> Mole a #

acosh :: Mole a -> Mole a #

atanh :: Mole a -> Mole a #

log1p :: Mole a -> Mole a #

expm1 :: Mole a -> Mole a #

log1pexp :: Mole a -> Mole a #

log1mexp :: Mole a -> Mole a #

Methods

floatRadix :: Mole a -> Integer #

floatDigits :: Mole a -> Int #

floatRange :: Mole a -> (Int, Int) #

decodeFloat :: Mole a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Mole a #

exponent :: Mole a -> Int #

significand :: Mole a -> Mole a #

scaleFloat :: Int -> Mole a -> Mole a #

isNaN :: Mole a -> Bool #

isInfinite :: Mole a -> Bool #

isDenormalized :: Mole a -> Bool #

isNegativeZero :: Mole a -> Bool #

isIEEE :: Mole a -> Bool #

atan2 :: Mole a -> Mole a -> Mole a #

Methods

(+) :: Mole a -> Mole a -> Mole a #

(-) :: Mole a -> Mole a -> Mole a #

(*) :: Mole a -> Mole a -> Mole a #

negate :: Mole a -> Mole a #

abs :: Mole a -> Mole a #

signum :: Mole a -> Mole a #

fromInteger :: Integer -> Mole a #

Methods

(/) :: Mole a -> Mole a -> Mole a #

recip :: Mole a -> Mole a #

fromRational :: Rational -> Mole a #

Methods

toRational :: Mole a -> Rational #

Methods

properFraction :: Integral b => Mole a -> (b, Mole a) #

truncate :: Integral b => Mole a -> b #

round :: Integral b => Mole a -> b #

ceiling :: Integral b => Mole a -> b #

floor :: Integral b => Mole a -> b #

Methods

showsPrec :: Int -> Mole a -> ShowS #

show :: Mole a -> String #

showList :: [Mole a] -> ShowS #

Methods

(==) :: Mole a -> Mole a -> Bool #

(/=) :: Mole a -> Mole a -> Bool #

Methods

compare :: Mole a -> Mole a -> Ordering #

(<) :: Mole a -> Mole a -> Bool #

(<=) :: Mole a -> Mole a -> Bool #

(>) :: Mole a -> Mole a -> Bool #

(>=) :: Mole a -> Mole a -> Bool #

max :: Mole a -> Mole a -> Mole a #

min :: Mole a -> Mole a -> Mole a #

Methods

showsDimPrec :: Int -> ShowS Source #

showDim :: String Source #

prettysDimPrec :: Int -> ShowS Source #

prettyDim :: String Source #

Methods

pi :: Current a #

exp :: Current a -> Current a #

log :: Current a -> Current a #

sqrt :: Current a -> Current a #

(**) :: Current a -> Current a -> Current a #

logBase :: Current a -> Current a -> Current a #

sin :: Current a -> Current a #

cos :: Current a -> Current a #

tan :: Current a -> Current a #

asin :: Current a -> Current a #

acos :: Current a -> Current a #

atan :: Current a -> Current a #

sinh :: Current a -> Current a #

cosh :: Current a -> Current a #

tanh :: Current a -> Current a #

asinh :: Current a -> Current a #

acosh :: Current a -> Current a #

atanh :: Current a -> Current a #

log1p :: Current a -> Current a #

expm1 :: Current a -> Current a #

log1pexp :: Current a -> Current a #

log1mexp :: Current a -> Current a #

Methods

floatRadix :: Current a -> Integer #

floatDigits :: Current a -> Int #

floatRange :: Current a -> (Int, Int) #

decodeFloat :: Current a -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Current a #

exponent :: Current a -> Int #

significand :: Current a -> Current a #

scaleFloat :: Int -> Current a -> Current a #

isNaN :: Current a -> Bool #

isInfinite :: Current a -> Bool #

isDenormalized :: Current a -> Bool #

isNegativeZero :: Current a -> Bool #

isIEEE :: Current a -> Bool #

atan2 :: Current a -> Current a -> Current a #

Methods

(+) :: Current a -> Current a -> Current a #

(-) :: Current a -> Current a -> Current a #

(*) :: Current a -> Current a -> Current a #

negate :: Current a -> Current a #

abs :: Current a -> Current a #

signum :: Current a -> Current a #

fromInteger :: Integer -> Current a #

Methods

(/) :: Current a -> Current a -> Current a #

recip :: Current a -> Current a #

fromRational :: Rational -> Current a #

Methods

toRational :: Current a -> Rational #

Methods

properFraction :: Integral b => Current a -> (b, Current a) #

truncate :: Integral b => Current a -> b #

round :: Integral b => Current a -> b #

ceiling :: Integral b => Current a -> b #

floor :: Integral b => Current a -> b #

Methods

showsPrec :: Int -> Current a -> ShowS #

show :: Current a -> String #

showList :: [Current a] -> ShowS #

Methods

(==) :: Current a -> Current a -> Bool #

(/=) :: Current a -> Current a -> Bool #

Methods

compare :: Current a -> Current a -> Ordering #

(<) :: Current a -> Current a -> Bool #

(<=) :: Current a -> Current a -> Bool #

(>) :: Current a -> Current a -> Bool #

(>=) :: Current a -> Current a -> Bool #

max :: Current a -> Current a -> Current a #

min :: Current a -> Current a -> Current a #

Methods

showsUnitPrec :: Int -> ShowS Source #

showUnit :: String Source #

prettysUnitPrec :: Int -> ShowS Source #

prettyUnit :: String Source #