ClassyPrelude-0.1: Prelude replacement using classes instead of concrete types where reasonable

Prelude.Math

Description

Prelude.Classy, plus some mathematical/floating-point functions

Synopsis

# Mathematical functions

gcd :: Integral a => a -> a -> a

`gcd x y` is the greatest (positive) integer that divides both `x` and `y`; for example `gcd (-3) 6` = `3`, `gcd (-3) (-6)` = `3`, `gcd 0 4` = `4`. `gcd 0 0` raises a runtime error.

lcm :: Integral a => a -> a -> a

`lcm x y` is the smallest positive integer that both `x` and `y` divide.

# Fixed/floating-point math

module Data.Ratio

data Float

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Instances

 Enum Float Eq Float Floating Float Fractional Float Num Float Ord Float Read Float Real Float RealFloat Float RealFrac Float Show Float

data Double

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

class Num a => Fractional a where

Fractional numbers, supporting real division.

Minimal complete definition: `fromRational` and (`recip` or `(/)`)

Methods

(/) :: a -> a -> a

fractional division

recip :: a -> a

reciprocal fraction

fromRational :: Rational -> a

Conversion from a `Rational` (that is `Ratio Integer`). A floating literal stands for an application of `fromRational` to a value of type `Rational`, so such literals have type `(Fractional a) => a`.

Instances

 Fractional Double Fractional Float Integral a => Fractional (Ratio a)

class Fractional a => Floating a where

Trigonometric and hyperbolic functions and related functions.

Minimal complete definition: `pi`, `exp`, `log`, `sin`, `cos`, `sinh`, `cosh`, `asin`, `acos`, `atan`, `asinh`, `acosh` and `atanh`

Methods

pi :: a

exp :: a -> a

sqrt :: a -> a

log :: a -> a

(**) :: a -> a -> a

logBase :: a -> a -> a

sin :: a -> a

tan :: a -> a

cos :: a -> a

asin :: a -> a

atan :: a -> a

acos :: a -> a

sinh :: a -> a

tanh :: a -> a

cosh :: a -> a

asinh :: a -> a

atanh :: a -> a

acosh :: a -> a

Instances

 Floating Double Floating Float

class (Real a, Fractional a) => RealFrac a where

Extracting components of fractions.

Minimal complete definition: `properFraction`

Methods

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

The function `properFraction` takes a real fractional number `x` and returns a pair `(n,f)` such that `x = n+f`, and:

• `n` is an integral number with the same sign as `x`; and
• `f` is a fraction with the same type and sign as `x`, and with absolute value less than `1`.

The default definitions of the `ceiling`, `floor`, `truncate` and `round` functions are in terms of `properFraction`.

truncate :: Integral b => a -> b

`truncate x` returns the integer nearest `x` between zero and `x`

round :: Integral b => a -> b

`round x` returns the nearest integer to `x`; the even integer if `x` is equidistant between two integers

ceiling :: Integral b => a -> b

`ceiling x` returns the least integer not less than `x`

floor :: Integral b => a -> b

`floor x` returns the greatest integer not greater than `x`

Instances

 RealFrac Double RealFrac Float Integral a => RealFrac (Ratio a)

class (RealFrac a, Floating a) => RealFloat a where

Minimal complete definition: all except `exponent`, `significand`, `scaleFloat` and `atan2`

Methods

a constant function, returning the radix of the representation (often `2`)

floatDigits :: a -> Int

a constant function, returning the number of digits of `floatRadix` in the significand

floatRange :: a -> (Int, Int)

a constant function, returning the lowest and highest values the exponent may assume

decodeFloat :: a -> (Integer, Int)

The function `decodeFloat` applied to a real floating-point number returns the significand expressed as an `Integer` and an appropriately scaled exponent (an `Int`). If `decodeFloat x` yields `(m,n)`, then `x` is equal in value to `m*b^^n`, where `b` is the floating-point radix, and furthermore, either `m` and `n` are both zero or else `b^(d-1) <= m < b^d`, where `d` is the value of `floatDigits x`. In particular, `decodeFloat 0 = (0,0)`.

encodeFloat :: Integer -> Int -> a

`encodeFloat` performs the inverse of `decodeFloat`

exponent :: a -> Int

the second component of `decodeFloat`.

significand :: a -> a

the first component of `decodeFloat`, scaled to lie in the open interval (`-1`,`1`)

scaleFloat :: Int -> a -> a

multiplies a floating-point number by an integer power of the radix

isNaN :: a -> Bool

`True` if the argument is an IEEE "not-a-number" (NaN) value

isInfinite :: a -> Bool

`True` if the argument is an IEEE infinity or negative infinity

isDenormalized :: a -> Bool

`True` if the argument is too small to be represented in normalized format

isNegativeZero :: a -> Bool

`True` if the argument is an IEEE negative zero

isIEEE :: a -> Bool

`True` if the argument is an IEEE floating point number

atan2 :: a -> a -> a

a version of arctangent taking two real floating-point arguments. For real floating `x` and `y`, `atan2 y x` computes the angle (from the positive x-axis) of the vector from the origin to the point `(x,y)`. `atan2 y x` returns a value in the range [`-pi`, `pi`]. It follows the Common Lisp semantics for the origin when signed zeroes are supported. `atan2 y 1`, with `y` in a type that is `RealFloat`, should return the same value as `atan y`. A default definition of `atan2` is provided, but implementors can provide a more accurate implementation.

Instances

 RealFloat Double RealFloat Float

(^^) :: (Fractional a, Integral b) => a -> b -> a

raise a number to an integral power

realToFrac :: (Real a, Fractional b) => a -> b

general coercion to fractional types