Algebra.Absolute

Documentation

class C a => C a where

This is the type class of a ring with a notion of an absolute value, satisfying the laws

                       a * b === b * a
  a /= 0  =>  abs (signum a) === 1
            abs a * signum a === a

Minimal definition: abs, signum.

If the type is in the Ord class we expect abs = absOrd and signum = signumOrd and we expect the following laws to hold:

     a + (max b c) === max (a+b) (a+c)
  negate (max b c) === min (negate b) (negate c)
     a * (max b c) === max (a*b) (a*c) where a >= 0
          absOrd a === max a (-a)

If the type is ZeroTestable, then it should hold

 isZero a  ===  signum a == signum (negate a)

We do not require Ord as superclass since we also want to have Number.Complex as instance. We also do not require ZeroTestable as superclass, because we like to have expressions of foreign languages to be instances (cf. embedded domain specific language approach, EDSL), as well as function types.

abs for complex numbers alone may have an inappropriate type, because it does not reflect that the absolute value is a real number. You might prefer magnitude. This type class is intended for unifying algorithms that work for both real and complex numbers. Note the similarity to Algebra.Units: abs plays the role of stdAssociate and signum plays the role of stdUnit.

Actually, since abs can be defined using max and negate we could relax the superclasses to Additive and Ord if his class would only contain signum.

Minimal complete definition

abs, signum

Methods

abs :: a -> a

signum :: a -> a

Instances

C Double

Defined in Algebra.Absolute

Methods

abs :: Double -> Double

signum :: Double -> Double

C Float

Defined in Algebra.Absolute

Methods

abs :: Float -> Float

signum :: Float -> Float

C Int

Defined in Algebra.Absolute

Methods

abs :: Int -> Int

signum :: Int -> Int

C Int8

Defined in Algebra.Absolute

Methods

abs :: Int8 -> Int8

signum :: Int8 -> Int8

C Int16

Defined in Algebra.Absolute

Methods

abs :: Int16 -> Int16

signum :: Int16 -> Int16

C Int32

Defined in Algebra.Absolute

Methods

abs :: Int32 -> Int32

signum :: Int32 -> Int32

C Int64

Defined in Algebra.Absolute

Methods

abs :: Int64 -> Int64

signum :: Int64 -> Int64

C Integer

Defined in Algebra.Absolute

Methods

abs :: Integer -> Integer

signum :: Integer -> Integer

C Word

Defined in Algebra.Absolute

Methods

abs :: Word -> Word

signum :: Word -> Word

C Word8

Defined in Algebra.Absolute

Methods

abs :: Word8 -> Word8

signum :: Word8 -> Word8

C Word16

Defined in Algebra.Absolute

Methods

abs :: Word16 -> Word16

signum :: Word16 -> Word16

C Word32

Defined in Algebra.Absolute

Methods

abs :: Word32 -> Word32

signum :: Word32 -> Word32

C Word64

Defined in Algebra.Absolute

Methods

abs :: Word64 -> Word64

signum :: Word64 -> Word64

C T

Defined in Number.Peano

Methods

abs :: T -> T

signum :: T -> T

C T

Defined in Number.FixedPoint.Check

Methods

abs :: T -> T

signum :: T -> T

C T

Defined in Number.Positional.Check

Methods

abs :: T -> T

signum :: T -> T

(C a, Ord a, C a) => C (T a)

Defined in Number.NonNegative

Methods

abs :: T a -> T a

signum :: T a -> T a

(C a, C a) => C (T a)

Defined in Number.Ratio

Methods

abs :: T a -> T a

signum :: T a -> T a

Num a => C (T a)

Defined in MathObj.Wrapper.Haskell98

Methods

abs :: T a -> T a

signum :: T a -> T a

(C a, C a, C a) => C (T a)

Defined in Number.NonNegativeChunky

Methods

abs :: T a -> T a

signum :: T a -> T a

(C a, C a, C a) => C (T a)

Defined in Number.Complex

Methods

abs :: T a -> T a

signum :: T a -> T a

C a => C (T a)

Defined in MathObj.Wrapper.NumericPrelude

Methods

abs :: T a -> T a

signum :: T a -> T a

C v => C (T a v)

Defined in Number.OccasionallyScalarExpression

Methods

abs :: T a v -> T a v

signum :: T a v -> T a v

(Ord i, C a) => C (T i a)

Defined in Number.Physical

Methods

abs :: T i a -> T i a

signum :: T i a -> T i a

C v => C (T a v)

Defined in Number.SI

Methods

abs :: T a v -> T a v

signum :: T a v -> T a v

absOrd :: (C a, Ord a) => a -> a

signumOrd :: (C a, Ord a) => a -> a