num

Parse an integral number.

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)
• 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. 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.

Numeric instances for Convertible. Copyright (C) 2009-2011 John Goerzen jgoerzen@complete.org All rights reserved. For license and copyright information, see the file LICENSE These instances perform conversion between numeric types such as Double, Int, Integer, Rational, and the like. Here are some notes about the conversion process: Conversions from floating-point types such as Double to integral types are done via the truncate function. This is a somewhat arbitrary decision; if you need different behavior, you will have to write your own instance or manually perform the conversion. All conversions perform bounds checking. If a value is too large for its destination type, you will get a ConvertError informing you of this. Note that this behavior differs from functions in the Haskell standard libraries, which will perform the conversion without error, but give you garbage in the end. Conversions do not perform precision checking; loss of precision is implied with certain conversions (for instance, Double to Float) and this is not an error.

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.

The Num class and the Integer type.

x * 2 ^ y

Provides the exact same API as Numeric.Backprop, except requiring Num instances for all types involved instead of Backprop instances. This was the original API of the library (for version 0.1). Num is strictly more powerful than Backprop, and is a stronger constraint on types than is necessary for proper backpropagating. In particular, fromInteger is a problem for many types, preventing useful backpropagation for lists, variable-length vectors (like Data.Vector) and variable-size matrices from linear algebra libraries like hmatrix and accelerate. However, this module might be useful in situations where you are working with external types with Num instances, and you want to avoid writing orphan instances for external types. If you have external types that are not Num instances, consider instead Numeric.Backprop.External. If you need a Num instance for tuples, you can use the orphan instances in the <https://hackage.haskell.org/package/NumInstances NumInstances> package (in particular, Data.NumInstances.Tuple) if you are writing an application and do not have to worry about orphan instances. See Numeric.Backprop for fuller documentation on using these functions.

Provides the exact same API as Prelude.Backprop, except requiring Num instances for all types involved instead of Backprop instances.