Number.Physical

Numeric values combined with abstract Physical Units

Documentation

data T i a

A Physics.Quantity.Value.T combines a numeric value with a physical unit.

Constructors

Cons (T i) a

Instances

(Ord i, C a v) => C a (T i v)

Defined in Number.Physical

Methods

(*>) :: a -> T i v -> T i v

(Ord i, C a v) => C a (T i v)

Defined in Number.Physical

C a v => C a (T i v)

Defined in Number.Physical

Methods

toScalar :: T i v -> a

toMaybeScalar :: T i v -> Maybe a

fromScalar :: a -> T i v

Monad (T i)

Defined in Number.Physical

Methods

(>>=) :: T i a -> (a -> T i b) -> T i b

(>>) :: T i a -> T i b -> T i b

return :: a -> T i a

Functor (T i)

Defined in Number.Physical

Methods

fmap :: (a -> b) -> T i a -> T i b

(<$) :: a -> T i b -> T i a

Applicative (T a)

Defined in Number.Physical

Methods

pure :: a0 -> T a a0

(<*>) :: T a (a0 -> b) -> T a a0 -> T a b

liftA2 :: (a0 -> b -> c) -> T a a0 -> T a b -> T a c

(*>) :: T a a0 -> T a b -> T a b

(<*) :: T a a0 -> T a b -> T a a0

Ord i => C (T i)

Defined in Number.Physical

Methods

zero :: C a => T i a

(<+>) :: C a => T i a -> T i a -> T i a

(*>) :: C a => a -> T i a -> T i a

(Eq i, Eq a) => Eq (T i a)

Defined in Number.Physical

Methods

(==) :: T i a -> T i a -> Bool

(/=) :: T i a -> T i a -> Bool

(Ord i, Ord a) => Ord (T i a)

Defined in Number.Physical

Methods

compare :: T i a -> T i a -> Ordering

(<) :: T i a -> T i a -> Bool

(<=) :: T i a -> T i a -> Bool

(>) :: T i a -> T i a -> Bool

(>=) :: T i a -> T i a -> Bool

max :: T i a -> T i a -> T i a

min :: T i a -> T i a -> T i a

(Ord i, Enum i, Show a) => Show (T i a)

Defined in Number.Physical

Methods

showsPrec :: Int -> T i a -> ShowS

show :: T i a -> String

showList :: [T i a] -> ShowS

(Ord i, C a) => C (T i a)

Defined in Number.Physical

Methods

zero :: T i a

(+) :: T i a -> T i a -> T i a

(-) :: T i a -> T i a -> T i a

negate :: T i a -> T i a

C v => C (T a v)

Defined in Number.Physical

Methods

isZero :: T a v -> Bool

(Ord i, C a) => C (T i a)

Defined in Number.Physical

Methods

(*) :: T i a -> T i a -> T i a

one :: T i a

fromInteger :: Integer -> T i a

(^) :: T i a -> Integer -> T i a

(Ord i, C a) => C (T i a)

Defined in Number.Physical

Methods

abs :: T i a -> T i a

signum :: T i a -> T i a

(Ord i, C a) => C (T i a)

Defined in Number.Physical

Methods

(/) :: T i a -> T i a -> T i a

recip :: T i a -> T i a

fromRational' :: Rational -> T i a

(^-) :: T i a -> Integer -> T i a

(Ord i, C a) => C (T i a)

Defined in Number.Physical

Methods

sqrt :: T i a -> T i a

root :: Integer -> T i a -> T i a

(^/) :: T i a -> Rational -> T i a

(Ord i, C a) => C (T i a)

Defined in Number.Physical

Methods

pi :: T i a

exp :: T i a -> T i a

log :: T i a -> T i a

logBase :: T i a -> T i a -> T i a

(**) :: T i a -> T i a -> T i a

sin :: T i a -> T i a

cos :: T i a -> T i a

tan :: T i a -> T i a

asin :: T i a -> T i a

acos :: T i a -> T i a

atan :: T i a -> T i a

sinh :: T i a -> T i a

cosh :: T i a -> T i a

tanh :: T i a -> T i a

asinh :: T i a -> T i a

acosh :: T i a -> T i a

atanh :: T i a -> T i a

quantity :: (Ord i, Enum i, C a) => [Int] -> a -> T i a

Construct a physical value from a numeric value and the full vector representation of a unit.

fromScalarSingle :: a -> T i a

isScalar :: T i a -> Bool

Test for the neutral Unit.T. Also a zero has a unit!

lift :: (a -> b) -> T i a -> T i b

apply a function to the numeric value while preserving the unit

lift2 :: Eq i => String -> (a -> b -> c) -> T i a -> T i b -> T i c

lift2Maybe :: Eq i => (a -> b -> c) -> T i a -> T i b -> Maybe (T i c)

lift2Gen :: Eq i => String -> (a -> b -> c) -> T i a -> T i b -> c

errorUnitMismatch :: String -> a

addMaybe :: (Eq i, C a) => T i a -> T i a -> Maybe (T i a)

Add two values if the units match, otherwise return Nothing

subMaybe :: (Eq i, C a) => T i a -> T i a -> Maybe (T i a)

Subtract two values if the units match, otherwise return Nothing

scale :: (Ord i, C a) => a -> T i a -> T i a

ratPow :: C a => T Int -> T i a -> T i a

ratPowMaybe :: C a => T Int -> T i a -> Maybe (T i a)

fromRatio :: (C b, C a) => T a -> b