Num -package:base-prelude -package:hledger-web is:module

The Num class and the Integer type.

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.

The Num class and the Integer type.

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.

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.

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

Deprecated: This module will be removed in the next major release.

Provides numerical data types and functions.

A wrapper that provides instances of Haskell 98 and NumericPrelude numeric type classes for types that have NumericPrelude instances.

New users with are strongly encouraged to see if Data.Text.ICU.NumberFormatter fits their use case. Although not deprecated, this header is provided for backwards compatibility only.

Number formatter implemented as bindings to the International Components for Unicode (ICU) libraries.

A generalized version of the class hirarchy for numbers. All functions that would break a potential deep embedding are removed or generalized to support deep embeddings. The class hierarchy for numeric types keeps as close as possible to the Prelude hierarchy. A great part of the default implementation and comments are copied and adopted from Prelude.