Boolean-0.2: Generalized booleans and numbers

Stability experimental jbra@informatik.uni-kiel.de Safe-Inferred

Data.Boolean.Numbers

Description

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 hirarchy for numeric types keeps as close as possible to the Prelude hirarchy. A great part of the default implementation and comments are copied and adopted from Prelude. -----------------------------------------------------------------------

Synopsis

Documentation

class Num a => NumB a whereSource

An extension of Num that supplies the integer type of a given number type and a way to create that number from the integer.

Associated Types

type IntegerOf a Source

The accociated integer type of the number.

Methods

fromIntegerB :: IntegerOf a -> aSource

Construct the number from the associated integer.

Instances

 NumB Double NumB Float NumB Int NumB Integer

class (NumB a, OrdB a) => IntegralB a whereSource

A deep embedded version of Integral. Integral numbers, supporting integer division.

Minimal complete definition is either quotRem and divMod or the other four functions. Besides that toIntegerB always has to be implemented.

Methods

quot :: a -> a -> aSource

Integer division truncated towards zero.

rem :: a -> a -> aSource

Integer reminder, satisfying: (x quot y) * y + (x rem y) == x

div :: a -> a -> aSource

Integer division truncated toward negative infinity.

mod :: a -> a -> aSource

Integer modulus, satisfying: (x div y) * y + (x mod y) == x

quotRem :: a -> a -> (a, a)Source

Simultaneous quot and rem.

divMod :: a -> a -> (a, a)Source

Simultaneous div and mod.

toIntegerB :: a -> IntegerOf aSource

Create a integer from this integral.

Instances

 IntegralB Int IntegralB Integer

class (NumB a, OrdB a, Fractional a) => RealFracB a whereSource

Deep embedded version of RealFloat. Extracting components of fractions.

Minimal complete definition: properFraction, round, floor and ceiling.

Methods

properFraction :: (IntegerOf a ~ IntegerOf b, IntegralB b) => a -> (b, a)Source

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 :: (IntegerOf a ~ IntegerOf b, IntegralB b) => a -> bSource

truncate x returns the integer nearest x between zero and x

round :: (IntegerOf a ~ IntegerOf b, IntegralB b) => a -> bSource

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

ceiling :: (IntegerOf a ~ IntegerOf b, IntegralB b) => a -> bSource

ceiling x returns the least integer not less than x

floor :: (IntegerOf a ~ IntegerOf b, IntegralB b) => a -> bSource

floor x returns the greatest integer not greater than x.

Instances

 RealFracB Double RealFracB Float

class (Boolean (BooleanOf a), RealFracB a, Floating a) => RealFloatB a whereSource

Deep embedded version of RealFloat. Efficient, machine-independent access to the components of a floating-point number.

A complete definition has to define all functions.

Methods

isNaN :: a -> BooleanOf aSource

true if the argument is an IEEE "not-a-number" (NaN) value.

isInfinite :: a -> BooleanOf aSource

true if the argument is an IEEE infinity or negative infinity.

isNegativeZero :: a -> BooleanOf aSource

true if the argument is an IEEE negative zero.

isIEEE :: a -> BooleanOf aSource

true if the argument is an IEEE floating point number.

atan2 :: a -> a -> aSource

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 RealFloatB, should return the same value as atan y.

Instances

 RealFloatB Double RealFloatB Float

evenB :: (IfB a, EqB a, IntegralB a) => a -> BooleanOf aSource

Variant of even for generalized booleans.

oddB :: (IfB a, EqB a, IntegralB a) => a -> BooleanOf aSource

Variant of odd for generalized booleans.

fromIntegralB :: (IntegerOf a ~ IntegerOf b, IntegralB a, NumB b) => a -> bSource

Variant of fromIntegral for generalized booleans.