Num -package:mixed-types-num -package:distribution-opensuse -package:relude -package:convertible

Basic numeric class. The Haskell Report defines no laws for Num. However, (+) and (*) are customarily expected to define a ring and have the following properties:

• Associativity of (+) (x + y) + z = x + (y + z)
• Commutativity of (+) x + y = y + x
• fromInteger 0 is the additive identity x + fromInteger 0 = x
• negate gives the additive inverse x + negate x = fromInteger 0
• Associativity of (*) (x * y) * z = x * (y * z)
• fromInteger 1 is the multiplicative identity x * fromInteger 1 = x and fromInteger 1 * x = x
• Distributivity of (*) with respect to (+) a * (b + c) = (a * b) + (a * c) and (b + c) * a = (b * a) + (c * a)
• Coherence with toInteger if the type also implements Integral, then fromInteger is a left inverse for toInteger, i.e. fromInteger (toInteger i) == i

Note that it isn't customarily expected that a type instance of both Num and Ord implement an ordered ring. Indeed, in base only Integer and Rational do.

The Num class and the Integer type.

Basic numeric class. The Haskell Report defines no laws for Num. However, (+) and (*) are customarily expected to define a ring and have the following properties:

• Associativity of (+) (x + y) + z = x + (y + z)
• Commutativity of (+) x + y = y + x
• fromInteger 0 is the additive identity x + fromInteger 0 = x
• negate gives the additive inverse x + negate x = fromInteger 0
• Associativity of (*) (x * y) * z = x * (y * z)
• fromInteger 1 is the multiplicative identity x * fromInteger 1 = x and fromInteger 1 * x = x
• Distributivity of (*) with respect to (+) a * (b + c) = (a * b) + (a * c) and (b + c) * a = (b * a) + (c * a)

Note that it isn't customarily expected that a type instance of both Num and Ord implement an ordered ring. Indeed, in base only Integer and Rational do.

Basic numeric class. The Haskell Report defines no laws for Num. However, (+) and (*) are customarily expected to define a ring and have the following properties:

• Associativity of (+) (x + y) + z = x + (y + z)
• Commutativity of (+) x + y = y + x
• fromInteger 0 is the additive identity x + fromInteger 0 = x
• negate gives the additive inverse x + negate x = fromInteger 0
• Associativity of (*) (x * y) * z = x * (y * z)
• fromInteger 1 is the multiplicative identity x * fromInteger 1 = x and fromInteger 1 * x = x
• Distributivity of (*) with respect to (+) a * (b + c) = (a * b) + (a * c) and (b + c) * a = (b * a) + (c * a)
• Coherence with toInteger if the type also implements Integral, then fromInteger is a left inverse for toInteger, i.e. fromInteger (toInteger i) == i

Note that it isn't customarily expected that a type instance of both Num and Ord implement an ordered ring. Indeed, in base only Integer and Rational do.

Basic numeric class.

Basic numeric class. The Haskell Report defines no laws for Num. However, '(+)' and '(*)' are customarily expected to define a ring and have the following properties:

• Associativity of (+) (x + y) + z = x + (y + z)
• Commutativity of (+) x + y = y + x
• fromInteger 0 is the additive identity x + fromInteger 0 = x
• negate gives the additive inverse x + negate x = fromInteger 0
• Associativity of (*) (x * y) * z = x * (y * z)
• fromInteger 1 is the multiplicative identity x * fromInteger 1 = x and fromInteger 1 * x = x
• Distributivity of (*) with respect to (+) a * (b + c) = (a * b) + (a * c) and (b + c) * a = (b * a) + (c * a)

Note that it isn't customarily expected that a type instance of both Num and Ord implement an ordered ring. Indeed, in base only Integer and Rational do.

Number instances for MSFs that produce numbers. This allows you to use numeric operators with MSFs that output numbers, for example, you can write:

msf1 :: MSF Input Double -- defined however you want
msf2 :: MSF Input Double -- defined however you want
msf3 :: MSF Input Double
msf3 = msf1 + msf2

instead of

msf3 = (msf1 &&& msf2) >>> arr (uncurry (+))

Instances are provided for the type classes Num, Fractional and Floating.

x * 2 ^ y

Simple coordinate in current user coordinate.

Parse an integral number number.

Odds and ends, mostly functions for reading and showing RealFloat-like kind of values.