Safe Haskell	None
Language	GHC2021

NumHask

Contents

Usage
Overview
Prelude Mappings
Extensions
Additive
Multiplicative
Ring
Field
Lattice
Action
Metric
Complex
Integral
Rational
Exceptions

Description

Numeric classes.

Synopsis

class Additive a where
- (+) :: a -> a -> a
- zero :: a
sum :: (Additive a, Foldable f) => f a -> a
accsum :: (Additive a, Traversable f) => f a -> f a
class Additive a => Subtractive a where
- negate :: a -> a
- (-) :: a -> a -> a
class Multiplicative a where
- (*) :: a -> a -> a
- one :: a
product :: (Multiplicative a, Foldable f) => f a -> a
accproduct :: (Multiplicative a, Traversable f) => f a -> f a
class Multiplicative a => Divisive a where
- recip :: a -> a
- (/) :: a -> a -> a
type Distributive a = (Additive a, Multiplicative a)
type Ring a = (Distributive a, Subtractive a)
class Distributive a => StarSemiring a where
- star :: a -> a
- plus :: a -> a
class (StarSemiring a, Idempotent a) => KleeneAlgebra a
class Distributive a => InvolutiveRing a where
- adj :: a -> a
two :: (Multiplicative a, Additive a) => a
type Field a = (Ring a, Divisive a)
class Field a => ExpField a where
- exp :: a -> a
- log :: a -> a
- (**) :: a -> a -> a
- logBase :: a -> a -> a
- sqrt :: a -> a
class SemiField a => QuotientField a where
- type Whole a
- properFraction :: a -> (Whole a, a)
- round :: a -> Whole a
- ceiling :: a -> Whole a
- floor :: a -> Whole a
- truncate :: a -> Whole a
class Field a => TrigField a where
- pi :: a
- sin :: a -> a
- cos :: a -> a
- tan :: a -> a
- asin :: a -> a
- acos :: a -> a
- atan :: a -> a
- atan2 :: a -> a -> a
- sinh :: a -> a
- cosh :: a -> a
- tanh :: a -> a
- asinh :: a -> a
- acosh :: a -> a
- atanh :: a -> a
infinity :: SemiField a => a
negInfinity :: Field a => a
nan :: SemiField a => a
half :: (Additive a, Divisive a) => a
class Eq a => JoinSemiLattice a where
- (\/) :: a -> a -> a
joinLeq :: JoinSemiLattice a => a -> a -> Bool
(<\) :: JoinSemiLattice a => a -> a -> Bool
class Eq a => MeetSemiLattice a where
- (/\) :: a -> a -> a
meetLeq :: MeetSemiLattice a => a -> a -> Bool
(</) :: MeetSemiLattice a => a -> a -> Bool
class JoinSemiLattice a => BoundedJoinSemiLattice a where
- bottom :: a
class MeetSemiLattice a => BoundedMeetSemiLattice a where
- top :: a
class Additive (AdditiveScalar m) => AdditiveAction m where
- type AdditiveScalar m
- (|+) :: m -> AdditiveScalar m -> m
(+|) :: AdditiveAction m => AdditiveScalar m -> m -> m
class (AdditiveAction m, Subtractive (AdditiveScalar m)) => SubtractiveAction m where
- (|-) :: m -> AdditiveScalar m -> m
(-|) :: (AdditiveAction m, Subtractive m) => AdditiveScalar m -> m -> m
class Multiplicative (Scalar m) => MultiplicativeAction m where
- type Scalar m
- (|*) :: m -> Scalar m -> m
(*|) :: MultiplicativeAction m => Scalar m -> m -> m
class (Divisive (Scalar m), MultiplicativeAction m) => DivisiveAction m where
- (|/) :: m -> Scalar m -> m
(/|) :: (MultiplicativeAction m, Divisive m) => Scalar m -> m -> m
type Module m = (Distributive (Scalar m), MultiplicativeAction m)
class Distributive (Mag a) => Basis a where
- type Mag a
- type Base a
- magnitude :: a -> Mag a
- basis :: a -> Base a
type Absolute a = (Basis a, Mag a ~ a)
type Sign a = (Basis a, Base a ~ a)
type EndoBased a = (Basis a, Mag a ~ a, Base a ~ a)
abs :: Absolute a => a -> a
signum :: Sign a => a -> a
distance :: (Basis a, Subtractive a) => a -> a -> Mag a
class (Distributive coord, Distributive (Dir coord)) => Direction coord where
- type Dir coord
- angle :: coord -> Dir coord
- ray :: Dir coord -> coord
data Polar a = Polar {
- radial :: a
- azimuth :: a
}
polar :: (Dir (Base a) ~ Mag a, Basis a, Direction (Base a)) => a -> Polar (Mag a)
coord :: (Scalar m ~ Dir m, MultiplicativeAction m, Direction m) => Polar (Scalar m) -> m
class (Eq a, Additive a) => Epsilon a where
- epsilon :: a
aboutEqual :: (Epsilon a, Lattice a, Subtractive a) => a -> a -> Bool
nearZero :: (Epsilon a, Lattice a, Subtractive a) => a -> Bool
(~=) :: (Epsilon a, Lattice a, Subtractive a) => a -> a -> Bool
newtype Complex a = Complex {
- complexPair :: (a, a)
}
(+:) :: a -> a -> Complex a
realPart :: Complex a -> a
imagPart :: Complex a -> a
class Distributive a => Integral a where
- div :: a -> a -> a
- mod :: a -> a -> a
- divMod :: a -> a -> (a, a)
- quot :: a -> a -> a
- rem :: a -> a -> a
- quotRem :: a -> a -> (a, a)
class ToIntegral a b where
- toIntegral :: a -> b
type ToInt a = ToIntegral a Int
class FromIntegral a b where
- fromIntegral :: b -> a
class FromInteger a where
- fromInteger :: Integer -> a
type FromInt a = FromIntegral a Int
even :: (Eq a, Integral a) => a -> Bool
odd :: (Eq a, Integral a) => a -> Bool
(^^) :: (Ord b, Divisive a, Subtractive b, Integral b) => a -> b -> a
(^) :: Divisive a => a -> Int -> a
data Ratio a = !a :% !a
type Rational = Ratio Integer
class ToRatio a b where
- toRatio :: a -> Ratio b
class FromRatio a b where
- fromRatio :: Ratio b -> a
class FromRational a where
- fromRational :: Rational -> a
reduce :: (Eq a, Subtractive a, EndoBased a, Integral a) => a -> a -> Ratio a
gcd :: (Eq a, EndoBased a, Integral a) => a -> a -> a
newtype NumHaskException = NumHaskException {
- errorMessage :: String
}
throw :: forall a e. (HasCallStack, Exception e) => e -> a

Usage

>>> :m -Prelude
>>> :set -XRebindableSyntax
>>> import NumHask.Prelude
>>> 1+1
2

Overview

numhask is largely a set of classes that can replace the Num class and it's descendents. Principles that have guided design include:

balanced class density. The numeric hierarchy begins with addition and multiplication, choosing not to build from a Magma base. Whilst not being as principled as other approaches, this circumvents the instance explosion problems of Haskell whilst maintaining clarity of class purpose.
operator-first. In all cases, a class exists to define useful operators. Major class groupings, such as Distributive, Ring and Field are type synonyms.
lawful. All classes have laws associated with them that serve to relate class operators together in a meaningful way.
low-impact. The library attempts to fit in with the rest of the Haskell ecosystem. It provides instances for common numbers: Int, Integer, Double, Float, Natural, and the Word classes. It avoids name (or idea) clashes with other popular libraries and adopts conventions in the current prelude where they make sense.
proof-of-concept. The library may be below industrial-strength depending on a definition of this term. At the same time, correspondence around improving the library is most welcome.

The class heirarchy looks somewhat like this:

classes

Prelude Mappings

Num is a very old part of haskell, and is virtually unchanged since its specification in haskell98.

A deconstruction of Num and mapping to numhask.

-- | Basic numeric class.
class  Num a  where
   {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}

   (+), (-), (*)       :: a -> a -> a
   -- | Unary negation.
   negate              :: a -> a

(+) is an operator of the Additive class

(-) & negate are functions in the Subtractive class, and

(*) is an operator of the Multiplicative class.

zero and one are also introduced to the numeric hierarchy.

   -- | Absolute value.
   abs                 :: a -> a
   -- | Sign of a number.
   -- The functions 'abs' and 'signum' should satisfy the law:
   --
   -- > abs x * signum x == x
   --
   -- For real numbers, the 'signum' is either @-1@ (negative), @0@ (zero)
   -- or @1@ (positive).
   signum              :: a -> a

The concept of an absolute value and the sign of a number can include situations where the domain type is different to the absolute and sign codomain types.

A new class, Basis is supplied to handle these situations:

the magnitude method is a generalisation of abs
the basis method is a generalisation of signum

abs and signum are specialisations of these methods.

   -- | Conversion from an 'Integer'.
   -- An integer literal represents the application of the function
   -- 'fromInteger' to the appropriate value of type 'Integer',
   -- so such literals have type @('Num' a) => a@.
   fromInteger         :: Integer -> a

FromInteger becomes its own class and FromIntegral is introduced to polymorphise the covariant.

Mappings from other areas of prelude include:

Integral becomes Integral and a polymorphic ToIntegral is introduced.
Fractional is roughly synonymous to Field together with a polymorphic FromRatio.
RealFrac becomes QuotientField with a polymorphic Whole type using Type Families.
Floating is split into ExpField and TrigField
RealFloat is not attempted. Life is too short.
Complex is resupplied in Complex but with some functionality deriving via EuclideanPair. The underlying representation has also been switched to a newtype-wrapped tuple.

In addition to base changes, alternatives to sum and product from Foldable are also supplied.

Extensions

RebindableSyntax is recommended for use with numhask.

As a replacement for the numerical classes, numhask clashes significantly with an unqualified import of the Prelude. Either numhask modules should be qualified, or prelude turned off with the NoImplicitPrelude extension, or with RebindableSyntax, which implies NoImplicitPrelude.

defaulting

Without RebindableSyntax, numeric literals default as follows:

>>> :set -XNoRebindableSyntax
>>> :t 1
1 :: Num a => a

>>> :t 1.0
1.0 :: Fractional a => a

With RebindableSyntax (which also switches NoImplicitPrelude on) literal numbers change to the numhask types, FromInteger and FromRational:

>>> :set -XRebindableSyntax
>>> :t 1
1 :: FromInteger a => a

>>> :t 1.0
1.0 :: FromRational a => a

>>> 1
1

>>> 1.0
1.0

RebindableSyntax is a tradeoff, however, and usage comes attached with other non-numeric changes that NumHask.Prelude attempts to counteract.

See haskell2010 Section 4.3.4 for the nuts and bolts to defaulting.

The effect of ExtendedDefaultRules in ghci or switched on as an extension also need to be understood. It can lead to unusual interactions with numerics and strange error messages at times because it adds () and [] to the start of the type defaulting list.

Additive

class Additive a where Source #

or Addition

For practical reasons, we begin the class tree with Additive. Starting with Associative and Unital, or using Semigroup and Monoid from base tends to confuse the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.

\a -> zero + a == a

\a -> a + zero == a

\a b c -> (a + b) + c == a + (b + c)

\a b -> a + b == b + a

By convention, (+) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative addition seems a bit dogmatic.

>>> zero + 1
1

>>> 1 + 1
2

Methods

(+) :: a -> a -> a infixl 6 Source #

zero :: a Source #

Instances

Instances details

Additive Int16 Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Int16 -> Int16 -> Int16 Source # zero :: Int16 Source #
Additive Int32 Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Int32 -> Int32 -> Int32 Source # zero :: Int32 Source #
Additive Int64 Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Int64 -> Int64 -> Int64 Source # zero :: Int64 Source #
Additive Int8 Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Int8 -> Int8 -> Int8 Source # zero :: Int8 Source #
Additive Word16 Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Word16 -> Word16 -> Word16 Source # zero :: Word16 Source #
Additive Word32 Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Word32 -> Word32 -> Word32 Source # zero :: Word32 Source #
Additive Word64 Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Word64 -> Word64 -> Word64 Source # zero :: Word64 Source #
Additive Word8 Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Word8 -> Word8 -> Word8 Source # zero :: Word8 Source #
Additive Integer Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Integer -> Integer -> Integer Source # zero :: Integer Source #
Additive Natural Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Natural -> Natural -> Natural Source # zero :: Natural Source #
Additive Bool Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Bool -> Bool -> Bool Source # zero :: Bool Source #
Additive Double Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Double -> Double -> Double Source # zero :: Double Source #
Additive Float Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Float -> Float -> Float Source # zero :: Float Source #
Additive Int Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Int -> Int -> Int Source # zero :: Int Source #
Additive Word Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Word -> Word -> Word Source # zero :: Word Source #
Additive a => Additive (Sum a) Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: Sum a -> Sum a -> Sum a Source # zero :: Sum a Source #
Additive a => Additive (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods (+) :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source # zero :: EuclideanPair a Source #
Additive a => Additive (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods (+) :: Complex a -> Complex a -> Complex a Source # zero :: Complex a Source #
Additive a => Additive (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (+) :: Positive a -> Positive a -> Positive a Source # zero :: Positive a Source #
(Ord a, EndoBased a, Integral a, Ring a) => Additive (Ratio a) Source #
Instance details Defined in NumHask.Data.Rational Methods (+) :: Ratio a -> Ratio a -> Ratio a Source # zero :: Ratio a Source #
Additive a => Additive (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods (+) :: Wrapped a -> Wrapped a -> Wrapped a Source # zero :: Wrapped a Source #
Additive b => Additive (a -> b) Source #
Instance details Defined in NumHask.Algebra.Additive Methods (+) :: (a -> b) -> (a -> b) -> a -> b Source # zero :: a -> b Source #

sum :: (Additive a, Foldable f) => f a -> a Source #

Compute the sum of a Foldable.

>>> sum [0..10]
55

accsum :: (Additive a, Traversable f) => f a -> f a Source #

Compute the accumulating sum of a Traversable.

>>> accsum [0..10]
[0,1,3,6,10,15,21,28,36,45,55]

class Additive a => Subtractive a where Source #

or Subtraction

\a -> a - a == zero

\a -> negate a == zero - a

\a -> negate a + a == zero

\a -> a + negate a == zero

>>> negate 1
-1

>>> 1 - 2
-1

Minimal complete definition

(-) | negate

Methods

negate :: a -> a Source #

(-) :: a -> a -> a infixl 6 Source #

Instances

Instances details

Subtractive Int16 Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Int16 -> Int16 Source # (-) :: Int16 -> Int16 -> Int16 Source #
Subtractive Int32 Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Int32 -> Int32 Source # (-) :: Int32 -> Int32 -> Int32 Source #
Subtractive Int64 Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Int64 -> Int64 Source # (-) :: Int64 -> Int64 -> Int64 Source #
Subtractive Int8 Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Int8 -> Int8 Source # (-) :: Int8 -> Int8 -> Int8 Source #
Subtractive Word16 Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Word16 -> Word16 Source # (-) :: Word16 -> Word16 -> Word16 Source #
Subtractive Word32 Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Word32 -> Word32 Source # (-) :: Word32 -> Word32 -> Word32 Source #
Subtractive Word64 Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Word64 -> Word64 Source # (-) :: Word64 -> Word64 -> Word64 Source #
Subtractive Word8 Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Word8 -> Word8 Source # (-) :: Word8 -> Word8 -> Word8 Source #
Subtractive Integer Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Integer -> Integer Source # (-) :: Integer -> Integer -> Integer Source #
Subtractive Natural Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Natural -> Natural Source # (-) :: Natural -> Natural -> Natural Source #
Subtractive Double Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Double -> Double Source # (-) :: Double -> Double -> Double Source #
Subtractive Float Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Float -> Float Source # (-) :: Float -> Float -> Float Source #
Subtractive Int Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Int -> Int Source # (-) :: Int -> Int -> Int Source #
Subtractive Word Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: Word -> Word Source # (-) :: Word -> Word -> Word Source #
Subtractive a => Subtractive (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods negate :: EuclideanPair a -> EuclideanPair a Source # (-) :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source #
Subtractive a => Subtractive (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods negate :: Complex a -> Complex a Source # (-) :: Complex a -> Complex a -> Complex a Source #
(Ord a, EndoBased a, Integral a, Ring a) => Subtractive (Ratio a) Source #
Instance details Defined in NumHask.Data.Rational Methods negate :: Ratio a -> Ratio a Source # (-) :: Ratio a -> Ratio a -> Ratio a Source #
Subtractive a => Subtractive (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods negate :: Wrapped a -> Wrapped a Source # (-) :: Wrapped a -> Wrapped a -> Wrapped a Source #
Subtractive b => Subtractive (a -> b) Source #
Instance details Defined in NumHask.Algebra.Additive Methods negate :: (a -> b) -> a -> b Source # (-) :: (a -> b) -> (a -> b) -> a -> b Source #

Multiplicative

class Multiplicative a where Source #

or Multiplication

For practical reasons, we begin the class tree with Additive and Multiplicative. Starting with Associative and Unital, or using Semigroup and Monoid from base tends to confuse the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.

\a -> one * a == a

\a -> a * one == a

\a b c -> (a * b) * c == a * (b * c)

By convention, (*) is regarded as not necessarily commutative, but this is not universal, and the introduction of another symbol which means commutative multiplication seems a bit dogmatic.

>>> one * 2
2

>>> 2 * 3
6

Methods

(*) :: a -> a -> a infixl 7 Source #

one :: a Source #

Instances

Instances details

Multiplicative Int16 Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Int16 -> Int16 -> Int16 Source # one :: Int16 Source #
Multiplicative Int32 Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Int32 -> Int32 -> Int32 Source # one :: Int32 Source #
Multiplicative Int64 Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Int64 -> Int64 -> Int64 Source # one :: Int64 Source #
Multiplicative Int8 Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Int8 -> Int8 -> Int8 Source # one :: Int8 Source #
Multiplicative Word16 Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Word16 -> Word16 -> Word16 Source # one :: Word16 Source #
Multiplicative Word32 Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Word32 -> Word32 -> Word32 Source # one :: Word32 Source #
Multiplicative Word64 Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Word64 -> Word64 -> Word64 Source # one :: Word64 Source #
Multiplicative Word8 Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Word8 -> Word8 -> Word8 Source # one :: Word8 Source #
Multiplicative Integer Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Integer -> Integer -> Integer Source # one :: Integer Source #
Multiplicative Natural Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Natural -> Natural -> Natural Source # one :: Natural Source #
Multiplicative Bool Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Bool -> Bool -> Bool Source # one :: Bool Source #
Multiplicative Double Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Double -> Double -> Double Source # one :: Double Source #
Multiplicative Float Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Float -> Float -> Float Source # one :: Float Source #
Multiplicative Int Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Int -> Int -> Int Source # one :: Int Source #
Multiplicative Word Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: Word -> Word -> Word Source # one :: Word Source #
Multiplicative a => Multiplicative (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods (*) :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source # one :: EuclideanPair a Source #
(Subtractive a, Multiplicative a) => Multiplicative (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods (*) :: Complex a -> Complex a -> Complex a Source # one :: Complex a Source #
Multiplicative a => Multiplicative (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (*) :: Positive a -> Positive a -> Positive a Source # one :: Positive a Source #
(Ord a, EndoBased a, Integral a, Ring a) => Multiplicative (Ratio a) Source #
Instance details Defined in NumHask.Data.Rational Methods (*) :: Ratio a -> Ratio a -> Ratio a Source # one :: Ratio a Source #
Multiplicative a => Multiplicative (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods (*) :: Wrapped a -> Wrapped a -> Wrapped a Source # one :: Wrapped a Source #
Multiplicative b => Multiplicative (a -> b) Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods (*) :: (a -> b) -> (a -> b) -> a -> b Source # one :: a -> b Source #

product :: (Multiplicative a, Foldable f) => f a -> a Source #

Compute the product of a Foldable.

>>> product [1..5]
120

accproduct :: (Multiplicative a, Traversable f) => f a -> f a Source #

Compute the accumulating product of a Traversable.

>>> accproduct [1..5]
[1,2,6,24,120]

class Multiplicative a => Divisive a where Source #

or Division

Though unusual, the term Divisive usefully fits in with the grammer of other classes and avoids name clashes that occur with some popular libraries.

\(a :: Double) -> a / a ~= one || a == zero

\(a :: Double) -> recip a ~= one / a || a == zero

\(a :: Double) -> recip a * a ~= one || a == zero

\(a :: Double) -> a * recip a ~= one || a == zero

>>> recip 2.0
0.5

>>> 1 / 2
0.5

Minimal complete definition

(/) | recip

Methods

recip :: a -> a Source #

(/) :: a -> a -> a infixl 7 Source #

Instances

Instances details

Divisive Double Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods recip :: Double -> Double Source # (/) :: Double -> Double -> Double Source #
Divisive Float Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods recip :: Float -> Float Source # (/) :: Float -> Float -> Float Source #
(Subtractive a, Divisive a) => Divisive (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods recip :: EuclideanPair a -> EuclideanPair a Source # (/) :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source #
(Subtractive a, Divisive a) => Divisive (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods recip :: Complex a -> Complex a Source # (/) :: Complex a -> Complex a -> Complex a Source #
Divisive a => Divisive (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods recip :: Positive a -> Positive a Source # (/) :: Positive a -> Positive a -> Positive a Source #
(Ord a, EndoBased a, Integral a, Ring a) => Divisive (Ratio a) Source #
Instance details Defined in NumHask.Data.Rational Methods recip :: Ratio a -> Ratio a Source # (/) :: Ratio a -> Ratio a -> Ratio a Source #
Divisive a => Divisive (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods recip :: Wrapped a -> Wrapped a Source # (/) :: Wrapped a -> Wrapped a -> Wrapped a Source #
Divisive b => Divisive (a -> b) Source #
Instance details Defined in NumHask.Algebra.Multiplicative Methods recip :: (a -> b) -> a -> b Source # (/) :: (a -> b) -> (a -> b) -> a -> b Source #

Ring

type Distributive a = (Additive a, Multiplicative a) Source #

Distributive

\a b c -> a * (b + c) == a * b + a * c

\a b c -> (a + b) * c == a * c + b * c

\a -> zero * a == zero

\a -> a * zero == zero

The sneaking in of the Absorption laws here glosses over the possibility that the multiplicative zero element does not have to correspond with the additive unital zero.

type Ring a = (Distributive a, Subtractive a) Source #

A Ring is an abelian group under addition (Unital, Associative, Commutative, Invertible) and monoidal under multiplication (Unital, Associative), and where multiplication distributes over addition.

\a -> zero + a == a
\a -> a + zero == a
\a b c -> (a + b) + c == a + (b + c)
\a b -> a + b == b + a
\a -> a - a == zero
\a -> negate a == zero - a
\a -> negate a + a == zero
\a -> a + negate a == zero
\a -> one * a == a
\a -> a * one == a
\a b c -> (a * b) * c == a * (b * c)
\a b c -> a * (b + c) == a * b + a * c
\a b c -> (a + b) * c == a * c + b * c
\a -> zero * a == zero
\a -> a * zero == zero

class Distributive a => StarSemiring a where Source #

A StarSemiring is a semiring with an additional unary operator (star) satisfying:

\a -> star a == one + a * star a

Minimal complete definition

star | plus

Methods

star :: a -> a Source #

plus :: a -> a Source #

Instances

Instances details

StarSemiring a => StarSemiring (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods star :: Wrapped a -> Wrapped a Source # plus :: Wrapped a -> Wrapped a Source #

class (StarSemiring a, Idempotent a) => KleeneAlgebra a Source #

A Kleene Algebra is a Star Semiring with idempotent addition.

a * x + x = a ==> star a * x + x = x
x * a + x = a ==> x * star a + x = x

class Distributive a => InvolutiveRing a where Source #

Involutive Ring

adj (a + b) ==> adj a + adj b
adj (a * b) ==> adj a * adj b
adj one ==> one
adj (adj a) ==> a

Note: elements for which adj a == a are called "self-adjoint".

Minimal complete definition

Nothing

Methods

adj :: a -> a Source #

Instances

Instances details

InvolutiveRing Int16 Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Int16 -> Int16 Source #
InvolutiveRing Int32 Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Int32 -> Int32 Source #
InvolutiveRing Int64 Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Int64 -> Int64 Source #
InvolutiveRing Int8 Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Int8 -> Int8 Source #
InvolutiveRing Word16 Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Word16 -> Word16 Source #
InvolutiveRing Word32 Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Word32 -> Word32 Source #
InvolutiveRing Word64 Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Word64 -> Word64 Source #
InvolutiveRing Word8 Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Word8 -> Word8 Source #
InvolutiveRing Integer Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Integer -> Integer Source #
InvolutiveRing Natural Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Natural -> Natural Source #
InvolutiveRing Double Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Double -> Double Source #
InvolutiveRing Float Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Float -> Float Source #
InvolutiveRing Int Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Int -> Int Source #
InvolutiveRing Word Source #
Instance details Defined in NumHask.Algebra.Ring Methods adj :: Word -> Word Source #
(Distributive a, Subtractive a) => InvolutiveRing (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods adj :: Complex a -> Complex a Source #
InvolutiveRing a => InvolutiveRing (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods adj :: Wrapped a -> Wrapped a Source #

two :: (Multiplicative a, Additive a) => a Source #

Defining two requires adding the multiplicative unital to itself. In other words, the concept of two is a Ring one.

>>> two
2

Field

type Field a = (Ring a, Divisive a) Source #

A Field is a set on which addition, subtraction, multiplication, and division are defined. It is also assumed that multiplication is distributive over addition.

A summary of the rules inherited from super-classes of Field:

zero + a == a
a + zero == a
((a + b) + c) (a + (b + c))
a + b == b + a
a - a == zero
negate a == zero - a
negate a + a == zero
a + negate a == zero
one * a == a
a * one == a
((a * b) * c) == (a * (b * c))
(a * (b + c)) == (a * b + a * c)
((a + b) * c) == (a * c + b * c)
a * zero == zero
zero * a == zero
a / a == one || a == zero
recip a == one / a || a == zero
recip a * a == one || a == zero
a * recip a == one || a == zero

class Field a => ExpField a where Source #

A hyperbolic field class

\(a::Double) -> a < zero || (sqrt . (**2)) a == a

\(a::Double) -> a < zero || (log . exp) a ~= a

\(a::Double) (b::Double) -> (b < zero) || a <= zero || a == 1 || abs (a ** logBase a b - b) < 10 * epsilon

Minimal complete definition

exp, log

Methods

exp :: a -> a Source #

log :: a -> a Source #

(**) :: a -> a -> a Source #

logBase :: a -> a -> a Source #

log to the base of

>>> logBase 2 8
2.9999999999999996

sqrt :: a -> a Source #

square root

>>> sqrt 4
2.0

Instances

Instances details

ExpField Double Source #
Instance details Defined in NumHask.Algebra.Field Methods exp :: Double -> Double Source # log :: Double -> Double Source # (**) :: Double -> Double -> Double Source # logBase :: Double -> Double -> Double Source # sqrt :: Double -> Double Source #
ExpField Float Source #
Instance details Defined in NumHask.Algebra.Field Methods exp :: Float -> Float Source # log :: Float -> Float Source # (**) :: Float -> Float -> Float Source # logBase :: Float -> Float -> Float Source # sqrt :: Float -> Float Source #
(Ord a, TrigField a, ExpField a) => ExpField (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods exp :: EuclideanPair a -> EuclideanPair a Source # log :: EuclideanPair a -> EuclideanPair a Source # (**) :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source # logBase :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source # sqrt :: EuclideanPair a -> EuclideanPair a Source #
(Ord a, TrigField a, ExpField a) => ExpField (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods exp :: Complex a -> Complex a Source # log :: Complex a -> Complex a Source # (**) :: Complex a -> Complex a -> Complex a Source # logBase :: Complex a -> Complex a -> Complex a Source # sqrt :: Complex a -> Complex a Source #
ExpField a => ExpField (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods exp :: Wrapped a -> Wrapped a Source # log :: Wrapped a -> Wrapped a Source # (**) :: Wrapped a -> Wrapped a -> Wrapped a Source # logBase :: Wrapped a -> Wrapped a -> Wrapped a Source # sqrt :: Wrapped a -> Wrapped a Source #
ExpField b => ExpField (a -> b) Source #
Instance details Defined in NumHask.Algebra.Field Methods exp :: (a -> b) -> a -> b Source # log :: (a -> b) -> a -> b Source # (**) :: (a -> b) -> (a -> b) -> a -> b Source # logBase :: (a -> b) -> (a -> b) -> a -> b Source # sqrt :: (a -> b) -> a -> b Source #

class SemiField a => QuotientField a where Source #

Quotienting of a Field into a Ring

See Field of fractions

\a -> a - one < floor a <= a <= ceiling a < a + one

Minimal complete definition

properFraction

Associated Types

type Whole a Source #

Methods

properFraction :: a -> (Whole a, a) Source #

round :: a -> Whole a Source #

round to the nearest Int

Exact ties are managed by rounding down ties if the whole component is even.

>>> round (1.5 :: Double)
2

>>> round (2.5 :: Double)
2

default round :: (Subtractive a, Integral (Whole a), Eq (Whole a), Ord a, Subtractive (Whole a)) => a -> Whole a Source #

ceiling :: a -> Whole a Source #

supply the next upper whole component

>>> ceiling (1.001 :: Double)
2

default ceiling :: (Ord a, Distributive (Whole a)) => a -> Whole a Source #

floor :: a -> Whole a Source #

supply the previous lower whole component

>>> floor (1.001 :: Double)
1

default floor :: (Ord a, Subtractive (Whole a), Distributive (Whole a)) => a -> Whole a Source #

truncate :: a -> Whole a Source #

supply the whole component closest to zero

>>> floor (-1.001 :: Double)
-2

>>> truncate (-1.001 :: Double)
-1

default truncate :: Ord a => a -> Whole a Source #

Instances

Instances details

QuotientField Double Source #

Instance details

Defined in NumHask.Algebra.Field

Associated Types

type Whole Double
Instance details Defined in NumHask.Algebra.Field type Whole Double = Int

Methods

properFraction :: Double -> (Whole Double, Double) Source #

round :: Double -> Whole Double Source #

ceiling :: Double -> Whole Double Source #

floor :: Double -> Whole Double Source #

truncate :: Double -> Whole Double Source #

QuotientField Float Source #

Instance details

Defined in NumHask.Algebra.Field

Associated Types

type Whole Float
Instance details Defined in NumHask.Algebra.Field type Whole Float = Int

Methods

properFraction :: Float -> (Whole Float, Float) Source #

round :: Float -> Whole Float Source #

ceiling :: Float -> Whole Float Source #

floor :: Float -> Whole Float Source #

truncate :: Float -> Whole Float Source #

(QuotientField a, Subtractive a) => QuotientField (EuclideanPair a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Whole (EuclideanPair a)
Instance details Defined in NumHask.Algebra.Metric type Whole (EuclideanPair a) = EuclideanPair (Whole a)

Methods

properFraction :: EuclideanPair a -> (Whole (EuclideanPair a), EuclideanPair a) Source #

round :: EuclideanPair a -> Whole (EuclideanPair a) Source #

ceiling :: EuclideanPair a -> Whole (EuclideanPair a) Source #

floor :: EuclideanPair a -> Whole (EuclideanPair a) Source #

truncate :: EuclideanPair a -> Whole (EuclideanPair a) Source #

(Subtractive a, QuotientField a) => QuotientField (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Associated Types

type Whole (Complex a)
Instance details Defined in NumHask.Data.Complex type Whole (Complex a) = Complex (Whole a)

Methods

properFraction :: Complex a -> (Whole (Complex a), Complex a) Source #

round :: Complex a -> Whole (Complex a) Source #

ceiling :: Complex a -> Whole (Complex a) Source #

floor :: Complex a -> Whole (Complex a) Source #

truncate :: Complex a -> Whole (Complex a) Source #

QuotientField (Positive Double) Source #

Instance details

Defined in NumHask.Data.Positive

Associated Types

type Whole (Positive Double)
Instance details Defined in NumHask.Data.Positive type Whole (Positive Double) = Positive Int

Methods

properFraction :: Positive Double -> (Whole (Positive Double), Positive Double) Source #

round :: Positive Double -> Whole (Positive Double) Source #

ceiling :: Positive Double -> Whole (Positive Double) Source #

floor :: Positive Double -> Whole (Positive Double) Source #

truncate :: Positive Double -> Whole (Positive Double) Source #

(Ord a, EndoBased a, Absolute a, ToInt a, Integral a, Ring a) => QuotientField (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Associated Types

type Whole (Ratio a)
Instance details Defined in NumHask.Data.Rational type Whole (Ratio a) = Int

Methods

properFraction :: Ratio a -> (Whole (Ratio a), Ratio a) Source #

round :: Ratio a -> Whole (Ratio a) Source #

ceiling :: Ratio a -> Whole (Ratio a) Source #

floor :: Ratio a -> Whole (Ratio a) Source #

truncate :: Ratio a -> Whole (Ratio a) Source #

(Ord a, Eq (Whole a), Integral (Whole a), Subtractive (Whole a), Subtractive a, QuotientField a) => QuotientField (Wrapped a) Source #

Instance details

Defined in NumHask.Data.Wrapped

Associated Types

type Whole (Wrapped a)
Instance details Defined in NumHask.Data.Wrapped type Whole (Wrapped a) = Whole a

Methods

properFraction :: Wrapped a -> (Whole (Wrapped a), Wrapped a) Source #

round :: Wrapped a -> Whole (Wrapped a) Source #

ceiling :: Wrapped a -> Whole (Wrapped a) Source #

floor :: Wrapped a -> Whole (Wrapped a) Source #

truncate :: Wrapped a -> Whole (Wrapped a) Source #

class Field a => TrigField a where Source #

Trigonometric Field

The list of laws is quite long: trigonometric identities

Minimal complete definition

pi, sin, cos, asin, acos, atan, atan2, sinh, cosh, asinh, acosh, atanh

Methods

pi :: a Source #

sin :: a -> a Source #

cos :: a -> a Source #

tan :: a -> a Source #

asin :: a -> a Source #

acos :: a -> a Source #

atan :: a -> a Source #

atan2 :: a -> a -> a Source #

sinh :: a -> a Source #

cosh :: a -> a Source #

tanh :: a -> a Source #

asinh :: a -> a Source #

acosh :: a -> a Source #

atanh :: a -> a Source #

Instances

Instances details

TrigField Double Source #
Instance details Defined in NumHask.Algebra.Field Methods pi :: Double Source # sin :: Double -> Double Source # cos :: Double -> Double Source # tan :: Double -> Double Source # asin :: Double -> Double Source # acos :: Double -> Double Source # atan :: Double -> Double Source # atan2 :: Double -> Double -> Double Source # sinh :: Double -> Double Source # cosh :: Double -> Double Source # tanh :: Double -> Double Source # asinh :: Double -> Double Source # acosh :: Double -> Double Source # atanh :: Double -> Double Source #
TrigField Float Source #
Instance details Defined in NumHask.Algebra.Field Methods pi :: Float Source # sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # atan2 :: Float -> Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # acosh :: Float -> Float Source # atanh :: Float -> Float Source #
TrigField a => TrigField (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods pi :: Wrapped a Source # sin :: Wrapped a -> Wrapped a Source # cos :: Wrapped a -> Wrapped a Source # tan :: Wrapped a -> Wrapped a Source # asin :: Wrapped a -> Wrapped a Source # acos :: Wrapped a -> Wrapped a Source # atan :: Wrapped a -> Wrapped a Source # atan2 :: Wrapped a -> Wrapped a -> Wrapped a Source # sinh :: Wrapped a -> Wrapped a Source # cosh :: Wrapped a -> Wrapped a Source # tanh :: Wrapped a -> Wrapped a Source # asinh :: Wrapped a -> Wrapped a Source # acosh :: Wrapped a -> Wrapped a Source # atanh :: Wrapped a -> Wrapped a Source #
TrigField b => TrigField (a -> b) Source #
Instance details Defined in NumHask.Algebra.Field Methods pi :: a -> b Source # sin :: (a -> b) -> a -> b Source # cos :: (a -> b) -> a -> b Source # tan :: (a -> b) -> a -> b Source # asin :: (a -> b) -> a -> b Source # acos :: (a -> b) -> a -> b Source # atan :: (a -> b) -> a -> b Source # atan2 :: (a -> b) -> (a -> b) -> a -> b Source # sinh :: (a -> b) -> a -> b Source # cosh :: (a -> b) -> a -> b Source # tanh :: (a -> b) -> a -> b Source # asinh :: (a -> b) -> a -> b Source # acosh :: (a -> b) -> a -> b Source # atanh :: (a -> b) -> a -> b Source #

infinity :: SemiField a => a Source #

infinity is defined for any Field.

>>> one / zero + infinity
Infinity

>>> infinity + 1
Infinity

negInfinity :: Field a => a Source #

negative infinity

>>> negInfinity + infinity
NaN

nan :: SemiField a => a Source #

nan is defined as zero/zero

but note the (social) law:

>>> nan == zero / zero
False

half :: (Additive a, Divisive a) => a Source #

A half of one

>>> half :: Double
0.5

Lattice

class Eq a => JoinSemiLattice a where Source #

A algebraic structure with element joins: See Semilattice

Associativity: x \/ (y \/ z) == (x \/ y) \/ z
Commutativity: x \/ y == y \/ x
Idempotency:   x \/ x == x

Methods

(\/) :: a -> a -> a infixr 5 Source #

Instances

Instances details

JoinSemiLattice Int16 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Int16 -> Int16 -> Int16 Source #
JoinSemiLattice Int32 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Int32 -> Int32 -> Int32 Source #
JoinSemiLattice Int64 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Int64 -> Int64 -> Int64 Source #
JoinSemiLattice Int8 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Int8 -> Int8 -> Int8 Source #
JoinSemiLattice Word16 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Word16 -> Word16 -> Word16 Source #
JoinSemiLattice Word32 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Word32 -> Word32 -> Word32 Source #
JoinSemiLattice Word64 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Word64 -> Word64 -> Word64 Source #
JoinSemiLattice Word8 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Word8 -> Word8 -> Word8 Source #
JoinSemiLattice Integer Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Integer -> Integer -> Integer Source #
JoinSemiLattice Natural Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Natural -> Natural -> Natural Source #
JoinSemiLattice Bool Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Bool -> Bool -> Bool Source #
JoinSemiLattice Double Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Double -> Double -> Double Source #
JoinSemiLattice Float Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Float -> Float -> Float Source #
JoinSemiLattice Int Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Int -> Int -> Int Source #
JoinSemiLattice Word Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (\/) :: Word -> Word -> Word Source #
JoinSemiLattice a => JoinSemiLattice (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods (\/) :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source #
JoinSemiLattice a => JoinSemiLattice (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods (\/) :: Complex a -> Complex a -> Complex a Source #
JoinSemiLattice a => JoinSemiLattice (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (\/) :: Positive a -> Positive a -> Positive a Source #
(Ord a, Integral a, EndoBased a, Subtractive a) => JoinSemiLattice (Ratio a) Source #
Instance details Defined in NumHask.Data.Rational Methods (\/) :: Ratio a -> Ratio a -> Ratio a Source #
JoinSemiLattice a => JoinSemiLattice (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods (\/) :: Wrapped a -> Wrapped a -> Wrapped a Source #

joinLeq :: JoinSemiLattice a => a -> a -> Bool Source #

The partial ordering induced by the join-semilattice structure

(<\) :: JoinSemiLattice a => a -> a -> Bool infixr 6 Source #

The partial ordering induced by the join-semilattice structure

class Eq a => MeetSemiLattice a where Source #

A algebraic structure with element meets: See Semilattice

Associativity: x /\ (y /\ z) == (x /\ y) /\ z
Commutativity: x /\ y == y /\ x
Idempotency:   x /\ x == x

Methods

(/\) :: a -> a -> a infixr 6 Source #

Instances

Instances details

MeetSemiLattice Int16 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Int16 -> Int16 -> Int16 Source #
MeetSemiLattice Int32 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Int32 -> Int32 -> Int32 Source #
MeetSemiLattice Int64 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Int64 -> Int64 -> Int64 Source #
MeetSemiLattice Int8 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Int8 -> Int8 -> Int8 Source #
MeetSemiLattice Word16 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Word16 -> Word16 -> Word16 Source #
MeetSemiLattice Word32 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Word32 -> Word32 -> Word32 Source #
MeetSemiLattice Word64 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Word64 -> Word64 -> Word64 Source #
MeetSemiLattice Word8 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Word8 -> Word8 -> Word8 Source #
MeetSemiLattice Integer Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Integer -> Integer -> Integer Source #
MeetSemiLattice Natural Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Natural -> Natural -> Natural Source #
MeetSemiLattice Bool Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Bool -> Bool -> Bool Source #
MeetSemiLattice Double Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Double -> Double -> Double Source #
MeetSemiLattice Float Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Float -> Float -> Float Source #
MeetSemiLattice Int Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Int -> Int -> Int Source #
MeetSemiLattice Word Source #
Instance details Defined in NumHask.Algebra.Lattice Methods (/\) :: Word -> Word -> Word Source #
MeetSemiLattice a => MeetSemiLattice (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods (/\) :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source #
MeetSemiLattice a => MeetSemiLattice (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods (/\) :: Complex a -> Complex a -> Complex a Source #
MeetSemiLattice a => MeetSemiLattice (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (/\) :: Positive a -> Positive a -> Positive a Source #
(Ord a, Integral a, EndoBased a, Subtractive a) => MeetSemiLattice (Ratio a) Source #
Instance details Defined in NumHask.Data.Rational Methods (/\) :: Ratio a -> Ratio a -> Ratio a Source #
MeetSemiLattice a => MeetSemiLattice (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods (/\) :: Wrapped a -> Wrapped a -> Wrapped a Source #

meetLeq :: MeetSemiLattice a => a -> a -> Bool Source #

The partial ordering induced by the meet-semilattice structure

(</) :: MeetSemiLattice a => a -> a -> Bool infixr 6 Source #

The partial ordering induced by the meet-semilattice structure

class JoinSemiLattice a => BoundedJoinSemiLattice a where Source #

A join-semilattice with an identity element bottom for \/.

x \/ bottom == bottom

Methods

bottom :: a Source #

Instances

Instances details

BoundedJoinSemiLattice Int16 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Int16 Source #
BoundedJoinSemiLattice Int32 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Int32 Source #
BoundedJoinSemiLattice Int64 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Int64 Source #
BoundedJoinSemiLattice Int8 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Int8 Source #
BoundedJoinSemiLattice Word16 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Word16 Source #
BoundedJoinSemiLattice Word32 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Word32 Source #
BoundedJoinSemiLattice Word64 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Word64 Source #
BoundedJoinSemiLattice Word8 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Word8 Source #
BoundedJoinSemiLattice Natural Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Natural Source #
BoundedJoinSemiLattice Bool Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Bool Source #
BoundedJoinSemiLattice Double Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Double Source #
BoundedJoinSemiLattice Float Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Float Source #
BoundedJoinSemiLattice Int Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Int Source #
BoundedJoinSemiLattice Word Source #
Instance details Defined in NumHask.Algebra.Lattice Methods bottom :: Word Source #
BoundedJoinSemiLattice a => BoundedJoinSemiLattice (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods bottom :: EuclideanPair a Source #
BoundedJoinSemiLattice a => BoundedJoinSemiLattice (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods bottom :: Complex a Source #
(Additive a, JoinSemiLattice a) => BoundedJoinSemiLattice (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods bottom :: Positive a Source #
BoundedJoinSemiLattice a => BoundedJoinSemiLattice (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods bottom :: Wrapped a Source #

class MeetSemiLattice a => BoundedMeetSemiLattice a where Source #

A meet-semilattice with an identity element top for /\.

x /\ top == top

Methods

top :: a Source #

Instances

Instances details

BoundedMeetSemiLattice Int16 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Int16 Source #
BoundedMeetSemiLattice Int32 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Int32 Source #
BoundedMeetSemiLattice Int64 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Int64 Source #
BoundedMeetSemiLattice Int8 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Int8 Source #
BoundedMeetSemiLattice Word16 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Word16 Source #
BoundedMeetSemiLattice Word32 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Word32 Source #
BoundedMeetSemiLattice Word64 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Word64 Source #
BoundedMeetSemiLattice Word8 Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Word8 Source #
BoundedMeetSemiLattice Bool Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Bool Source #
BoundedMeetSemiLattice Double Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Double Source #
BoundedMeetSemiLattice Float Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Float Source #
BoundedMeetSemiLattice Int Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Int Source #
BoundedMeetSemiLattice Word Source #
Instance details Defined in NumHask.Algebra.Lattice Methods top :: Word Source #
BoundedMeetSemiLattice a => BoundedMeetSemiLattice (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods top :: EuclideanPair a Source #
BoundedMeetSemiLattice a => BoundedMeetSemiLattice (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods top :: Complex a Source #
BoundedMeetSemiLattice a => BoundedMeetSemiLattice (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods top :: Positive a Source #
BoundedMeetSemiLattice a => BoundedMeetSemiLattice (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods top :: Wrapped a Source #

Action

class Additive (AdditiveScalar m) => AdditiveAction m where Source #

Additive Action

m |+ zero == m

Associated Types

type AdditiveScalar m Source #

Methods

(|+) :: m -> AdditiveScalar m -> m infixl 6 Source #

Instances

Instances details

AdditiveAction a => AdditiveAction (Positive a) Source #

Instance details

Defined in NumHask.Data.Positive

Associated Types

type AdditiveScalar (Positive a)
Instance details Defined in NumHask.Data.Positive type AdditiveScalar (Positive a) = AdditiveScalar (Wrapped a)

Methods

(|+) :: Positive a -> AdditiveScalar (Positive a) -> Positive a Source #

AdditiveAction a => AdditiveAction (Wrapped a) Source #

Instance details

Defined in NumHask.Data.Wrapped

Associated Types

type AdditiveScalar (Wrapped a)
Instance details Defined in NumHask.Data.Wrapped type AdditiveScalar (Wrapped a) = AdditiveScalar a

Methods

(|+) :: Wrapped a -> AdditiveScalar (Wrapped a) -> Wrapped a Source #

(+|) :: AdditiveAction m => AdditiveScalar m -> m -> m infixl 6 Source #

flipped additive action

(+|) == flip (|+)
zero +| m = m

class (AdditiveAction m, Subtractive (AdditiveScalar m)) => SubtractiveAction m where Source #

Subtractive Action

m |- zero = m

Methods

(|-) :: m -> AdditiveScalar m -> m infixl 6 Source #

Instances

Instances details

SubtractiveAction a => SubtractiveAction (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (\|-) :: Positive a -> AdditiveScalar (Positive a) -> Positive a Source #
SubtractiveAction a => SubtractiveAction (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods (\|-) :: Wrapped a -> AdditiveScalar (Wrapped a) -> Wrapped a Source #

(-|) :: (AdditiveAction m, Subtractive m) => AdditiveScalar m -> m -> m infixl 6 Source #

Subtraction with the scalar on the left

(-|) == (+|) . negate
zero -| m = negate m

class Multiplicative (Scalar m) => MultiplicativeAction m where Source #

Multiplicative Action

m |* one = m
m |* zero = zero

Associated Types

type Scalar m Source #

Methods

(|*) :: m -> Scalar m -> m infixl 7 Source #

Instances

Instances details

Multiplicative a => MultiplicativeAction (EuclideanPair a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Scalar (EuclideanPair a)
Instance details Defined in NumHask.Algebra.Metric type Scalar (EuclideanPair a) = a

Methods

(|*) :: EuclideanPair a -> Scalar (EuclideanPair a) -> EuclideanPair a Source #

MultiplicativeAction a => MultiplicativeAction (Positive a) Source #

Instance details

Defined in NumHask.Data.Positive

Associated Types

type Scalar (Positive a)
Instance details Defined in NumHask.Data.Positive type Scalar (Positive a) = Scalar (Wrapped a)

Methods

(|*) :: Positive a -> Scalar (Positive a) -> Positive a Source #

MultiplicativeAction a => MultiplicativeAction (Wrapped a) Source #

Instance details

Defined in NumHask.Data.Wrapped

Associated Types

type Scalar (Wrapped a)
Instance details Defined in NumHask.Data.Wrapped type Scalar (Wrapped a) = Scalar a

Methods

(|*) :: Wrapped a -> Scalar (Wrapped a) -> Wrapped a Source #

(*|) :: MultiplicativeAction m => Scalar m -> m -> m infixl 7 Source #

flipped multiplicative action

(*|) == flip (|*)
one *| m = one
zero *| m = zero

class (Divisive (Scalar m), MultiplicativeAction m) => DivisiveAction m where Source #

Divisive Action

m |/ one = m

Methods

(|/) :: m -> Scalar m -> m infixl 7 Source #

Instances

Instances details

Divisive a => DivisiveAction (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods (\|/) :: EuclideanPair a -> Scalar (EuclideanPair a) -> EuclideanPair a Source #
DivisiveAction a => DivisiveAction (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (\|/) :: Positive a -> Scalar (Positive a) -> Positive a Source #
DivisiveAction a => DivisiveAction (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods (\|/) :: Wrapped a -> Scalar (Wrapped a) -> Wrapped a Source #

(/|) :: (MultiplicativeAction m, Divisive m) => Scalar m -> m -> m Source #

left scalar division

(/|) == (*|) . recip
one |/ m = recip m

type Module m = (Distributive (Scalar m), MultiplicativeAction m) Source #

A Module

a *| one == a
(a + b) *| c == (a *| c) + (b *| c)
c |* (a + b) == (c |* a) + (c |* b)
a *| zero == zero
a *| b == b |* a

Metric

class Distributive (Mag a) => Basis a where Source #

Basis encapsulates the notion of magnitude (intuitively the quotienting of a higher-kinded number to a scalar one) and the basis on which the magnitude quotienting was performed. An instance needs to satisfy these laws:

\a -> magnitude a >= zero
\a -> magnitude zero == zero
\a -> a == magnitude a *| basis a
\a -> magnitude (basis a) == one

The names chosen are meant to represent the spiritual idea of a basis rather than a specific mathematics. See https://en.wikipedia.org/wiki/Basis_(linear_algebra) & https://en.wikipedia.org/wiki/Norm_(mathematics) for some mathematical motivations.

>>> magnitude (-0.5 :: Double)
0.5

>>> basis (-0.5 :: Double)
-1.0

Since: 0.11

Associated Types

type Mag a Source #

type Base a Source #

Methods

magnitude :: a -> Mag a Source #

or length, or ||v||

basis :: a -> Base a Source #

or direction, or v-hat

Instances

Instances details

Basis Int16 Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int16
Instance details Defined in NumHask.Algebra.Metric type Mag Int16 = Int16
type Base Int16
Instance details Defined in NumHask.Algebra.Metric type Base Int16 = Int16

Methods

magnitude :: Int16 -> Mag Int16 Source #

basis :: Int16 -> Base Int16 Source #

Basis Int32 Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int32
Instance details Defined in NumHask.Algebra.Metric type Mag Int32 = Int32
type Base Int32
Instance details Defined in NumHask.Algebra.Metric type Base Int32 = Int32

Methods

magnitude :: Int32 -> Mag Int32 Source #

basis :: Int32 -> Base Int32 Source #

Basis Int64 Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int64
Instance details Defined in NumHask.Algebra.Metric type Mag Int64 = Int64
type Base Int64
Instance details Defined in NumHask.Algebra.Metric type Base Int64 = Int64

Methods

magnitude :: Int64 -> Mag Int64 Source #

basis :: Int64 -> Base Int64 Source #

Basis Int8 Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int8
Instance details Defined in NumHask.Algebra.Metric type Mag Int8 = Int8
type Base Int8
Instance details Defined in NumHask.Algebra.Metric type Base Int8 = Int8

Methods

magnitude :: Int8 -> Mag Int8 Source #

basis :: Int8 -> Base Int8 Source #

Basis Word16 Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word16
Instance details Defined in NumHask.Algebra.Metric type Mag Word16 = Word16
type Base Word16
Instance details Defined in NumHask.Algebra.Metric type Base Word16 = Word16

Methods

magnitude :: Word16 -> Mag Word16 Source #

basis :: Word16 -> Base Word16 Source #

Basis Word32 Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word32
Instance details Defined in NumHask.Algebra.Metric type Mag Word32 = Word32
type Base Word32
Instance details Defined in NumHask.Algebra.Metric type Base Word32 = Word32

Methods

magnitude :: Word32 -> Mag Word32 Source #

basis :: Word32 -> Base Word32 Source #

Basis Word64 Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word64
Instance details Defined in NumHask.Algebra.Metric type Mag Word64 = Word64
type Base Word64
Instance details Defined in NumHask.Algebra.Metric type Base Word64 = Word64

Methods

magnitude :: Word64 -> Mag Word64 Source #

basis :: Word64 -> Base Word64 Source #

Basis Word8 Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word8
Instance details Defined in NumHask.Algebra.Metric type Mag Word8 = Word8
type Base Word8
Instance details Defined in NumHask.Algebra.Metric type Base Word8 = Word8

Methods

magnitude :: Word8 -> Mag Word8 Source #

basis :: Word8 -> Base Word8 Source #

Basis Integer Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Integer
Instance details Defined in NumHask.Algebra.Metric type Mag Integer = Integer
type Base Integer
Instance details Defined in NumHask.Algebra.Metric type Base Integer = Integer

Methods

magnitude :: Integer -> Mag Integer Source #

basis :: Integer -> Base Integer Source #

Basis Natural Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Natural
Instance details Defined in NumHask.Algebra.Metric type Mag Natural = Natural
type Base Natural
Instance details Defined in NumHask.Algebra.Metric type Base Natural = Natural

Methods

magnitude :: Natural -> Mag Natural Source #

basis :: Natural -> Base Natural Source #

Basis Double Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Double
Instance details Defined in NumHask.Algebra.Metric type Mag Double = Double
type Base Double
Instance details Defined in NumHask.Algebra.Metric type Base Double = Double

Methods

magnitude :: Double -> Mag Double Source #

basis :: Double -> Base Double Source #

Basis Float Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Float
Instance details Defined in NumHask.Algebra.Metric type Mag Float = Float
type Base Float
Instance details Defined in NumHask.Algebra.Metric type Base Float = Float

Methods

magnitude :: Float -> Mag Float Source #

basis :: Float -> Base Float Source #

Basis Int Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int
Instance details Defined in NumHask.Algebra.Metric type Mag Int = Int
type Base Int
Instance details Defined in NumHask.Algebra.Metric type Base Int = Int

Methods

magnitude :: Int -> Mag Int Source #

basis :: Int -> Base Int Source #

Basis Word Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word
Instance details Defined in NumHask.Algebra.Metric type Mag Word = Word
type Base Word
Instance details Defined in NumHask.Algebra.Metric type Base Word = Word

Methods

magnitude :: Word -> Mag Word Source #

basis :: Word -> Base Word Source #

(ExpField a, Eq a) => Basis (EuclideanPair a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag (EuclideanPair a)
Instance details Defined in NumHask.Algebra.Metric type Mag (EuclideanPair a) = a
type Base (EuclideanPair a)
Instance details Defined in NumHask.Algebra.Metric type Base (EuclideanPair a) = EuclideanPair a

Methods

magnitude :: EuclideanPair a -> Mag (EuclideanPair a) Source #

basis :: EuclideanPair a -> Base (EuclideanPair a) Source #

(Additive a, Multiplicative a) => Basis (Polar a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag (Polar a)
Instance details Defined in NumHask.Algebra.Metric type Mag (Polar a) = a
type Base (Polar a)
Instance details Defined in NumHask.Algebra.Metric type Base (Polar a) = a

Methods

magnitude :: Polar a -> Mag (Polar a) Source #

basis :: Polar a -> Base (Polar a) Source #

(ExpField a, Eq a) => Basis (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Associated Types

type Mag (Complex a)
Instance details Defined in NumHask.Data.Complex type Mag (Complex a) = Mag (EuclideanPair a)
type Base (Complex a)
Instance details Defined in NumHask.Data.Complex type Base (Complex a) = Base (EuclideanPair a)

Methods

magnitude :: Complex a -> Mag (Complex a) Source #

basis :: Complex a -> Base (Complex a) Source #

Basis a => Basis (Positive a) Source #

Instance details

Defined in NumHask.Data.Positive

Associated Types

type Mag (Positive a)
Instance details Defined in NumHask.Data.Positive type Mag (Positive a) = Mag (Wrapped a)
type Base (Positive a)
Instance details Defined in NumHask.Data.Positive type Base (Positive a) = Base (Wrapped a)

Methods

magnitude :: Positive a -> Mag (Positive a) Source #

basis :: Positive a -> Base (Positive a) Source #

(Ord a, EndoBased a, Integral a, Ring a) => Basis (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Associated Types

type Mag (Ratio a)
Instance details Defined in NumHask.Data.Rational type Mag (Ratio a) = Ratio a
type Base (Ratio a)
Instance details Defined in NumHask.Data.Rational type Base (Ratio a) = Ratio a

Methods

magnitude :: Ratio a -> Mag (Ratio a) Source #

basis :: Ratio a -> Base (Ratio a) Source #

Basis a => Basis (Wrapped a) Source #

Instance details

Defined in NumHask.Data.Wrapped

Associated Types

type Mag (Wrapped a)
Instance details Defined in NumHask.Data.Wrapped type Mag (Wrapped a) = Mag a
type Base (Wrapped a)
Instance details Defined in NumHask.Data.Wrapped type Base (Wrapped a) = Base a

Methods

magnitude :: Wrapped a -> Mag (Wrapped a) Source #

basis :: Wrapped a -> Base (Wrapped a) Source #

type Absolute a = (Basis a, Mag a ~ a) Source #

Basis where the domain and magnitude codomain are the same.

Since: 0.11

type Sign a = (Basis a, Base a ~ a) Source #

Basis where the domain and basis codomain are the same.

Since: 0.11

type EndoBased a = (Basis a, Mag a ~ a, Base a ~ a) Source #

Basis where the domain, magnitude codomain and basis codomain are the same.

Since: 0.11

abs :: Absolute a => a -> a Source #

The absolute value of a number.

\a -> abs a * signum a ~= a

>>> abs (-1)
1

signum :: Sign a => a -> a Source #

The sign of a number.

>>> signum (-1)
-1

abs zero == zero, so any value for signum zero is ok. We choose lawful neutral:

>>> signum zero == zero
True

Since: 0.11

distance :: (Basis a, Subtractive a) => a -> a -> Mag a Source #

Distance, which combines the Subtractive notion of difference, with Basis.

distance a b >= zero
distance a a == zero
distance a b *| basis (a - b) == a - b

class (Distributive coord, Distributive (Dir coord)) => Direction coord where Source #

Convert between a "co-ordinated" or "higher-kinded" number and a direction.

ray . angle == basis
magnitude (ray x) == one

Since: 0.7

Associated Types

type Dir coord Source #

Methods

angle :: coord -> Dir coord Source #

ray :: Dir coord -> coord Source #

Instances

Instances details

TrigField a => Direction (EuclideanPair a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Dir (EuclideanPair a)
Instance details Defined in NumHask.Algebra.Metric type Dir (EuclideanPair a) = a

Methods

angle :: EuclideanPair a -> Dir (EuclideanPair a) Source #

ray :: Dir (EuclideanPair a) -> EuclideanPair a Source #

TrigField a => Direction (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Associated Types

type Dir (Complex a)
Instance details Defined in NumHask.Data.Complex type Dir (Complex a) = Dir (EuclideanPair a)

Methods

angle :: Complex a -> Dir (Complex a) Source #

ray :: Dir (Complex a) -> Complex a Source #

Direction a => Direction (Positive a) Source #

Instance details

Defined in NumHask.Data.Positive

Associated Types

type Dir (Positive a)
Instance details Defined in NumHask.Data.Positive type Dir (Positive a) = Dir (Wrapped a)

Methods

angle :: Positive a -> Dir (Positive a) Source #

ray :: Dir (Positive a) -> Positive a Source #

Direction a => Direction (Wrapped a) Source #

Instance details

Defined in NumHask.Data.Wrapped

Associated Types

type Dir (Wrapped a)
Instance details Defined in NumHask.Data.Wrapped type Dir (Wrapped a) = Dir a

Methods

angle :: Wrapped a -> Dir (Wrapped a) Source #

ray :: Dir (Wrapped a) -> Wrapped a Source #

data Polar a Source #

Something that has a magnitude and a direction, with both expressed as the same type.

See Polar coordinate system

Since: 0.7

Constructors

Polar
Fields radial :: a azimuth :: a

Instances

Instances details

Generic (Polar a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Rep (Polar a)

Instance details

Defined in NumHask.Algebra.Metric

type Rep (Polar a) = D1 ('MetaData "Polar" "NumHask.Algebra.Metric" "numhask-0.12.1.0-Fm5yKjkWiRvEzHIePJHlTh" 'False) (C1 ('MetaCons "Polar" 'PrefixI 'True) (S1 ('MetaSel ('Just "radial") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "azimuth") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

Methods

from :: Polar a -> Rep (Polar a) x #

to :: Rep (Polar a) x -> Polar a #

Show a => Show (Polar a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Methods

showsPrec :: Int -> Polar a -> ShowS #

show :: Polar a -> String #

showList :: [Polar a] -> ShowS #

Eq a => Eq (Polar a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Methods

(==) :: Polar a -> Polar a -> Bool #

(/=) :: Polar a -> Polar a -> Bool #

(Additive a, Multiplicative a) => Basis (Polar a) Source #

Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag (Polar a)
Instance details Defined in NumHask.Algebra.Metric type Mag (Polar a) = a
type Base (Polar a)
Instance details Defined in NumHask.Algebra.Metric type Base (Polar a) = a

Methods

magnitude :: Polar a -> Mag (Polar a) Source #

basis :: Polar a -> Base (Polar a) Source #

type Rep (Polar a) Source #

Instance details

Defined in NumHask.Algebra.Metric

type Rep (Polar a) = D1 ('MetaData "Polar" "NumHask.Algebra.Metric" "numhask-0.12.1.0-Fm5yKjkWiRvEzHIePJHlTh" 'False) (C1 ('MetaCons "Polar" 'PrefixI 'True) (S1 ('MetaSel ('Just "radial") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "azimuth") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

type Base (Polar a) Source #

Instance details

Defined in NumHask.Algebra.Metric

type Base (Polar a) = a

type Mag (Polar a) Source #

Instance details

Defined in NumHask.Algebra.Metric

type Mag (Polar a) = a

polar :: (Dir (Base a) ~ Mag a, Basis a, Direction (Base a)) => a -> Polar (Mag a) Source #

Convert a higher-kinded number that has direction, to a Polar

Since: 0.7

coord :: (Scalar m ~ Dir m, MultiplicativeAction m, Direction m) => Polar (Scalar m) -> m Source #

Convert a Polar to a (higher-kinded) number that has a direction.

Since: 0.7

class (Eq a, Additive a) => Epsilon a where Source #

A small number, especially useful for approximate equality.

Minimal complete definition

Nothing

Methods

epsilon :: a Source #

Instances

Instances details

Epsilon Int16 Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Int16 Source #
Epsilon Int32 Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Int32 Source #
Epsilon Int64 Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Int64 Source #
Epsilon Int8 Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Int8 Source #
Epsilon Word16 Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Word16 Source #
Epsilon Word32 Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Word32 Source #
Epsilon Word64 Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Word64 Source #
Epsilon Word8 Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Word8 Source #
Epsilon Integer Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Integer Source #
Epsilon Double Source #	1e-14
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Double Source #
Epsilon Float Source #	1e-6
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Float Source #
Epsilon Int Source #	0
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Int Source #
Epsilon Word Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: Word Source #
Epsilon a => Epsilon (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods epsilon :: EuclideanPair a Source #
Epsilon a => Epsilon (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods epsilon :: Complex a Source #
Epsilon a => Epsilon (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods epsilon :: Positive a Source #
(Ord a, EndoBased a, Integral a, Ring a, MeetSemiLattice a) => Epsilon (Ratio a) Source #
Instance details Defined in NumHask.Data.Rational Methods epsilon :: Ratio a Source #
Epsilon a => Epsilon (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods epsilon :: Wrapped a Source #

aboutEqual :: (Epsilon a, Lattice a, Subtractive a) => a -> a -> Bool Source #

Approximate equality

>>> aboutEqual zero (epsilon :: Double)
True

nearZero :: (Epsilon a, Lattice a, Subtractive a) => a -> Bool Source #

Note that the constraint is Lattice rather than Ord allowing broader usage.

>>> nearZero (epsilon :: Double)
True

>>> nearZero (epsilon :: EuclideanPair Double)
True

(~=) :: (Epsilon a, Lattice a, Subtractive a) => a -> a -> Bool infixl 4 Source #

About equal operator.

>>> (1.0 + epsilon) ~= (1.0 :: Double)
True

Complex

newtype Complex a Source #

The underlying representation is a newtype-wrapped tuple, compared with the base datatype. This was chosen to facilitate the use of DerivingVia.

Constructors

Complex
Fields complexPair :: (a, a)

Instances

Instances details

Functor Complex Source #

Instance details

Defined in NumHask.Data.Complex

Methods

fmap :: (a -> b) -> Complex a -> Complex b #

(<$) :: a -> Complex b -> Complex a #

Data a => Data (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) #

toConstr :: Complex a -> Constr #

dataTypeOf :: Complex a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) #

gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

Generic (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Associated Types

type Rep (Complex a)
Instance details Defined in NumHask.Data.Complex type Rep (Complex a) = D1 ('MetaData "Complex" "NumHask.Data.Complex" "numhask-0.12.1.0-Fm5yKjkWiRvEzHIePJHlTh" 'True) (C1 ('MetaCons "Complex" 'PrefixI 'True) (S1 ('MetaSel ('Just "complexPair") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a, a))))

Methods

from :: Complex a -> Rep (Complex a) x #

to :: Rep (Complex a) x -> Complex a #

Read a => Read (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

readsPrec :: Int -> ReadS (Complex a) #

readList :: ReadS [Complex a] #

readPrec :: ReadPrec (Complex a) #

readListPrec :: ReadPrec [Complex a] #

Show a => Show (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

showsPrec :: Int -> Complex a -> ShowS #

show :: Complex a -> String #

showList :: [Complex a] -> ShowS #

Eq a => Eq (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

(==) :: Complex a -> Complex a -> Bool #

(/=) :: Complex a -> Complex a -> Bool #

Additive a => Additive (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

(+) :: Complex a -> Complex a -> Complex a Source #

zero :: Complex a Source #

Subtractive a => Subtractive (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

negate :: Complex a -> Complex a Source #

(-) :: Complex a -> Complex a -> Complex a Source #

(Ord a, TrigField a, ExpField a) => ExpField (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

exp :: Complex a -> Complex a Source #

log :: Complex a -> Complex a Source #

(**) :: Complex a -> Complex a -> Complex a Source #

logBase :: Complex a -> Complex a -> Complex a Source #

sqrt :: Complex a -> Complex a Source #

(Subtractive a, QuotientField a) => QuotientField (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Associated Types

type Whole (Complex a)
Instance details Defined in NumHask.Data.Complex type Whole (Complex a) = Complex (Whole a)

Methods

properFraction :: Complex a -> (Whole (Complex a), Complex a) Source #

round :: Complex a -> Whole (Complex a) Source #

ceiling :: Complex a -> Whole (Complex a) Source #

floor :: Complex a -> Whole (Complex a) Source #

truncate :: Complex a -> Whole (Complex a) Source #

BoundedJoinSemiLattice a => BoundedJoinSemiLattice (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

bottom :: Complex a Source #

BoundedMeetSemiLattice a => BoundedMeetSemiLattice (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

top :: Complex a Source #

JoinSemiLattice a => JoinSemiLattice (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

(\/) :: Complex a -> Complex a -> Complex a Source #

MeetSemiLattice a => MeetSemiLattice (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

(/\) :: Complex a -> Complex a -> Complex a Source #

(ExpField a, Eq a) => Basis (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Associated Types

type Mag (Complex a)
Instance details Defined in NumHask.Data.Complex type Mag (Complex a) = Mag (EuclideanPair a)
type Base (Complex a)
Instance details Defined in NumHask.Data.Complex type Base (Complex a) = Base (EuclideanPair a)

Methods

magnitude :: Complex a -> Mag (Complex a) Source #

basis :: Complex a -> Base (Complex a) Source #

TrigField a => Direction (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Associated Types

type Dir (Complex a)
Instance details Defined in NumHask.Data.Complex type Dir (Complex a) = Dir (EuclideanPair a)

Methods

angle :: Complex a -> Dir (Complex a) Source #

ray :: Dir (Complex a) -> Complex a Source #

Epsilon a => Epsilon (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

epsilon :: Complex a Source #

(Subtractive a, Divisive a) => Divisive (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

recip :: Complex a -> Complex a Source #

(/) :: Complex a -> Complex a -> Complex a Source #

(Subtractive a, Multiplicative a) => Multiplicative (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

(*) :: Complex a -> Complex a -> Complex a Source #

one :: Complex a Source #

(Distributive a, Subtractive a) => InvolutiveRing (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

Methods

adj :: Complex a -> Complex a Source #

(Additive a, FromIntegral a b) => FromIntegral (Complex a) b Source #

Instance details

Defined in NumHask.Data.Complex

Methods

fromIntegral :: b -> Complex a Source #

type Rep (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

type Rep (Complex a) = D1 ('MetaData "Complex" "NumHask.Data.Complex" "numhask-0.12.1.0-Fm5yKjkWiRvEzHIePJHlTh" 'True) (C1 ('MetaCons "Complex" 'PrefixI 'True) (S1 ('MetaSel ('Just "complexPair") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a, a))))

type Whole (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

type Whole (Complex a) = Complex (Whole a)

type Base (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

type Base (Complex a) = Base (EuclideanPair a)

type Dir (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

type Dir (Complex a) = Dir (EuclideanPair a)

type Mag (Complex a) Source #

Instance details

Defined in NumHask.Data.Complex

type Mag (Complex a) = Mag (EuclideanPair a)

(+:) :: a -> a -> Complex a infixl 6 Source #

Complex number constructor.

realPart :: Complex a -> a Source #

Extracts the real part of a complex number.

imagPart :: Complex a -> a Source #

Extracts the imaginary part of a complex number.

Integral

class Distributive a => Integral a where Source #

An Integral is anything that satisfies the law:

\a b -> b == zero || b * (a `div` b) + (a `mod` b) == a

>>> 3 `divMod` 2
(1,1)

>>> (-3) `divMod` 2
(-2,1)

>>> (-3) `quotRem` 2
(-1,-1)

Minimal complete definition

divMod, quotRem

Methods

div :: a -> a -> a infixl 7 Source #

mod :: a -> a -> a infixl 7 Source #

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

quot :: a -> a -> a Source #

rem :: a -> a -> a Source #

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

Instances

Instances details

Integral Int16 Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Int16 -> Int16 -> Int16 Source # mod :: Int16 -> Int16 -> Int16 Source # divMod :: Int16 -> Int16 -> (Int16, Int16) Source # quot :: Int16 -> Int16 -> Int16 Source # rem :: Int16 -> Int16 -> Int16 Source # quotRem :: Int16 -> Int16 -> (Int16, Int16) Source #
Integral Int32 Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Int32 -> Int32 -> Int32 Source # mod :: Int32 -> Int32 -> Int32 Source # divMod :: Int32 -> Int32 -> (Int32, Int32) Source # quot :: Int32 -> Int32 -> Int32 Source # rem :: Int32 -> Int32 -> Int32 Source # quotRem :: Int32 -> Int32 -> (Int32, Int32) Source #
Integral Int64 Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Int64 -> Int64 -> Int64 Source # mod :: Int64 -> Int64 -> Int64 Source # divMod :: Int64 -> Int64 -> (Int64, Int64) Source # quot :: Int64 -> Int64 -> Int64 Source # rem :: Int64 -> Int64 -> Int64 Source # quotRem :: Int64 -> Int64 -> (Int64, Int64) Source #
Integral Int8 Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Int8 -> Int8 -> Int8 Source # mod :: Int8 -> Int8 -> Int8 Source # divMod :: Int8 -> Int8 -> (Int8, Int8) Source # quot :: Int8 -> Int8 -> Int8 Source # rem :: Int8 -> Int8 -> Int8 Source # quotRem :: Int8 -> Int8 -> (Int8, Int8) Source #
Integral Word16 Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Word16 -> Word16 -> Word16 Source # mod :: Word16 -> Word16 -> Word16 Source # divMod :: Word16 -> Word16 -> (Word16, Word16) Source # quot :: Word16 -> Word16 -> Word16 Source # rem :: Word16 -> Word16 -> Word16 Source # quotRem :: Word16 -> Word16 -> (Word16, Word16) Source #
Integral Word32 Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Word32 -> Word32 -> Word32 Source # mod :: Word32 -> Word32 -> Word32 Source # divMod :: Word32 -> Word32 -> (Word32, Word32) Source # quot :: Word32 -> Word32 -> Word32 Source # rem :: Word32 -> Word32 -> Word32 Source # quotRem :: Word32 -> Word32 -> (Word32, Word32) Source #
Integral Word64 Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Word64 -> Word64 -> Word64 Source # mod :: Word64 -> Word64 -> Word64 Source # divMod :: Word64 -> Word64 -> (Word64, Word64) Source # quot :: Word64 -> Word64 -> Word64 Source # rem :: Word64 -> Word64 -> Word64 Source # quotRem :: Word64 -> Word64 -> (Word64, Word64) Source #
Integral Word8 Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Word8 -> Word8 -> Word8 Source # mod :: Word8 -> Word8 -> Word8 Source # divMod :: Word8 -> Word8 -> (Word8, Word8) Source # quot :: Word8 -> Word8 -> Word8 Source # rem :: Word8 -> Word8 -> Word8 Source # quotRem :: Word8 -> Word8 -> (Word8, Word8) Source #
Integral Integer Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Integer -> Integer -> Integer Source # mod :: Integer -> Integer -> Integer Source # divMod :: Integer -> Integer -> (Integer, Integer) Source # quot :: Integer -> Integer -> Integer Source # rem :: Integer -> Integer -> Integer Source # quotRem :: Integer -> Integer -> (Integer, Integer) Source #
Integral Natural Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Natural -> Natural -> Natural Source # mod :: Natural -> Natural -> Natural Source # divMod :: Natural -> Natural -> (Natural, Natural) Source # quot :: Natural -> Natural -> Natural Source # rem :: Natural -> Natural -> Natural Source # quotRem :: Natural -> Natural -> (Natural, Natural) Source #
Integral Int Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Int -> Int -> Int Source # mod :: Int -> Int -> Int Source # divMod :: Int -> Int -> (Int, Int) Source # quot :: Int -> Int -> Int Source # rem :: Int -> Int -> Int Source # quotRem :: Int -> Int -> (Int, Int) Source #
Integral Word Source #
Instance details Defined in NumHask.Data.Integral Methods div :: Word -> Word -> Word Source # mod :: Word -> Word -> Word Source # divMod :: Word -> Word -> (Word, Word) Source # quot :: Word -> Word -> Word Source # rem :: Word -> Word -> Word Source # quotRem :: Word -> Word -> (Word, Word) Source #
Integral a => Integral (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods div :: Positive a -> Positive a -> Positive a Source # mod :: Positive a -> Positive a -> Positive a Source # divMod :: Positive a -> Positive a -> (Positive a, Positive a) Source # quot :: Positive a -> Positive a -> Positive a Source # rem :: Positive a -> Positive a -> Positive a Source # quotRem :: Positive a -> Positive a -> (Positive a, Positive a) Source #
Integral a => Integral (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods div :: Wrapped a -> Wrapped a -> Wrapped a Source # mod :: Wrapped a -> Wrapped a -> Wrapped a Source # divMod :: Wrapped a -> Wrapped a -> (Wrapped a, Wrapped a) Source # quot :: Wrapped a -> Wrapped a -> Wrapped a Source # rem :: Wrapped a -> Wrapped a -> Wrapped a Source # quotRem :: Wrapped a -> Wrapped a -> (Wrapped a, Wrapped a) Source #
Integral b => Integral (a -> b) Source #
Instance details Defined in NumHask.Data.Integral Methods div :: (a -> b) -> (a -> b) -> a -> b Source # mod :: (a -> b) -> (a -> b) -> a -> b Source # divMod :: (a -> b) -> (a -> b) -> (a -> b, a -> b) Source # quot :: (a -> b) -> (a -> b) -> a -> b Source # rem :: (a -> b) -> (a -> b) -> a -> b Source # quotRem :: (a -> b) -> (a -> b) -> (a -> b, a -> b) Source #

class ToIntegral a b where Source #

toIntegral is kept separate from Integral to help with compatability issues.

toIntegral a == a

Methods

toIntegral :: a -> b Source #

Instances

Instances details

ToIntegral Int16 Int16 Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int16 -> Int16 Source #
ToIntegral Int16 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int16 -> Integer Source #
ToIntegral Int16 Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int16 -> Int Source #
ToIntegral Int32 Int32 Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int32 -> Int32 Source #
ToIntegral Int32 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int32 -> Integer Source #
ToIntegral Int32 Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int32 -> Int Source #
ToIntegral Int64 Int64 Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int64 -> Int64 Source #
ToIntegral Int64 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int64 -> Integer Source #
ToIntegral Int64 Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int64 -> Int Source #
ToIntegral Int8 Int8 Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int8 -> Int8 Source #
ToIntegral Int8 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int8 -> Integer Source #
ToIntegral Int8 Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int8 -> Int Source #
ToIntegral Word16 Word16 Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word16 -> Word16 Source #
ToIntegral Word16 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word16 -> Integer Source #
ToIntegral Word16 Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word16 -> Int Source #
ToIntegral Word32 Word32 Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word32 -> Word32 Source #
ToIntegral Word32 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word32 -> Integer Source #
ToIntegral Word32 Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word32 -> Int Source #
ToIntegral Word64 Word64 Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word64 -> Word64 Source #
ToIntegral Word64 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word64 -> Integer Source #
ToIntegral Word64 Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word64 -> Int Source #
ToIntegral Word8 Word8 Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word8 -> Word8 Source #
ToIntegral Word8 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word8 -> Integer Source #
ToIntegral Word8 Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word8 -> Int Source #
ToIntegral Integer Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Integer -> Integer Source #
ToIntegral Integer Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Integer -> Int Source #
ToIntegral Natural Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Natural -> Integer Source #
ToIntegral Natural Natural Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Natural -> Natural Source #
ToIntegral Natural Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Natural -> Int Source #
ToIntegral Int Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int -> Integer Source #
ToIntegral Int Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Int -> Int Source #
ToIntegral Word Integer Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word -> Integer Source #
ToIntegral Word Int Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word -> Int Source #
ToIntegral Word Word Source #
Instance details Defined in NumHask.Data.Integral Methods toIntegral :: Word -> Word Source #
ToIntegral a b => ToIntegral (Positive a) b Source #
Instance details Defined in NumHask.Data.Positive Methods toIntegral :: Positive a -> b Source #
ToIntegral a b => ToIntegral (Wrapped a) b Source #
Instance details Defined in NumHask.Data.Wrapped Methods toIntegral :: Wrapped a -> b Source #

type ToInt a = ToIntegral a Int Source #

Convert to an Int

class FromIntegral a b where Source #

Polymorphic version of fromInteger

fromIntegral a == a

Methods

fromIntegral :: b -> a Source #

Instances

Instances details

FromIntegral Int16 Int16 Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int16 -> Int16 Source #
FromIntegral Int16 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Int16 Source #
FromIntegral Int16 Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Int16 Source #
FromIntegral Int32 Int32 Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int32 -> Int32 Source #
FromIntegral Int32 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Int32 Source #
FromIntegral Int32 Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Int32 Source #
FromIntegral Int64 Int64 Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int64 -> Int64 Source #
FromIntegral Int64 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Int64 Source #
FromIntegral Int64 Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Int64 Source #
FromIntegral Int8 Int8 Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int8 -> Int8 Source #
FromIntegral Int8 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Int8 Source #
FromIntegral Int8 Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Int8 Source #
FromIntegral Word16 Word16 Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Word16 -> Word16 Source #
FromIntegral Word16 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Word16 Source #
FromIntegral Word16 Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Word16 Source #
FromIntegral Word32 Word32 Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Word32 -> Word32 Source #
FromIntegral Word32 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Word32 Source #
FromIntegral Word32 Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Word32 Source #
FromIntegral Word64 Word64 Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Word64 -> Word64 Source #
FromIntegral Word64 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Word64 Source #
FromIntegral Word64 Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Word64 Source #
FromIntegral Word8 Word8 Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Word8 -> Word8 Source #
FromIntegral Word8 Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Word8 Source #
FromIntegral Word8 Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Word8 Source #
FromIntegral Integer Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Integer Source #
FromIntegral Integer Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Integer Source #
FromIntegral Natural Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Natural Source #
FromIntegral Natural Natural Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Natural -> Natural Source #
FromIntegral Natural Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Natural Source #
FromIntegral Double Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Double Source #
FromIntegral Double Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Double Source #
FromIntegral Float Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Float Source #
FromIntegral Float Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Float Source #
FromIntegral Int Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Int Source #
FromIntegral Int Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Int Source #
FromIntegral Word Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Integer -> Word Source #
FromIntegral Word Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Int -> Word Source #
FromIntegral Word Word Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: Word -> Word Source #
(Additive a, FromIntegral a b) => FromIntegral (Complex a) b Source #
Instance details Defined in NumHask.Data.Complex Methods fromIntegral :: b -> Complex a Source #
(MeetSemiLattice a, Integral a) => FromIntegral (Positive a) a Source #
Instance details Defined in NumHask.Data.Positive Methods fromIntegral :: a -> Positive a Source #
FromIntegral a b => FromIntegral (Positive a) b Source #
Instance details Defined in NumHask.Data.Positive Methods fromIntegral :: b -> Positive a Source #
(FromIntegral a b, Multiplicative a) => FromIntegral (Ratio a) b Source #
Instance details Defined in NumHask.Data.Rational Methods fromIntegral :: b -> Ratio a Source #
FromIntegral a b => FromIntegral (Wrapped a) b Source #
Instance details Defined in NumHask.Data.Wrapped Methods fromIntegral :: b -> Wrapped a Source #
FromIntegral a b => FromIntegral (c -> a) b Source #
Instance details Defined in NumHask.Data.Integral Methods fromIntegral :: b -> c -> a Source #

class FromInteger a where Source #

fromInteger is special in two ways:

numeric integral literals (like "42") are interpreted specifically as "fromInteger (42 :: GHC.Num.Integer)". The prelude version is used as default (or whatever fromInteger is in scope if RebindableSyntax is set).
The default rules in haskell2010 specify that constraints on fromInteger need to be in a form C v, where v is a Num or a subclass of Num.

So a type synonym such as type FromInteger a = FromIntegral a Integer doesn't work well with type defaulting; hence the need for a separate class.

Methods

fromInteger :: Integer -> a Source #

Instances

Instances details

FromInteger Int16 Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Int16 Source #
FromInteger Int32 Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Int32 Source #
FromInteger Int64 Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Int64 Source #
FromInteger Int8 Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Int8 Source #
FromInteger Word16 Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Word16 Source #
FromInteger Word32 Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Word32 Source #
FromInteger Word64 Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Word64 Source #
FromInteger Word8 Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Word8 Source #
FromInteger Integer Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Integer Source #
FromInteger Natural Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Natural Source #
FromInteger Double Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Double Source #
FromInteger Float Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Float Source #
FromInteger Int Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Int Source #
FromInteger Word Source #
Instance details Defined in NumHask.Data.Integral Methods fromInteger :: Integer -> Word Source #
FromInteger a => FromInteger (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods fromInteger :: Integer -> Positive a Source #
FromInteger a => FromInteger (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods fromInteger :: Integer -> Wrapped a Source #

type FromInt a = FromIntegral a Int Source #

Convert from an Int

even :: (Eq a, Integral a) => a -> Bool Source #

>>> even 2
True

odd :: (Eq a, Integral a) => a -> Bool Source #

>>> odd 3
True

(^^) :: (Ord b, Divisive a, Subtractive b, Integral b) => a -> b -> a infixr 8 Source #

raise a number to an Integral power

>>> 2 ^^ 3
8.0

>>> 2 ^^ (-2)
0.25

(^) :: Divisive a => a -> Int -> a infixr 8 Source #

raise a number to an Int power

Note: This differs from (^) found in prelude which is a partial function (it errors on negative integrals). This is a monomorphic version of (^^) provided to help reduce ambiguous type noise in common usages.

>>> 2 ^ 3
8.0

>>> 2 ^ (-2)
0.25

Rational

data Ratio a Source #

A rational number, represented as the ratio of two Integral numbers.

Constructors

!a :% !a

Instances

Instances details

FromRatio Rational Integer Source #

Instance details

Defined in NumHask.Data.Rational

Methods

fromRatio :: Ratio Integer -> Rational Source #

Show a => Show (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

showsPrec :: Int -> Ratio a -> ShowS #

show :: Ratio a -> String #

showList :: [Ratio a] -> ShowS #

(Eq a, Subtractive a, EndoBased a, Absolute a, Integral a) => Eq (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

(==) :: Ratio a -> Ratio a -> Bool #

(/=) :: Ratio a -> Ratio a -> Bool #

(Ord a, Integral a, EndoBased a, Subtractive a) => Ord (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

compare :: Ratio a -> Ratio a -> Ordering #

(<) :: Ratio a -> Ratio a -> Bool #

(<=) :: Ratio a -> Ratio a -> Bool #

(>) :: Ratio a -> Ratio a -> Bool #

(>=) :: Ratio a -> Ratio a -> Bool #

max :: Ratio a -> Ratio a -> Ratio a #

min :: Ratio a -> Ratio a -> Ratio a #

(Ord a, EndoBased a, Integral a, Ring a) => Additive (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

(+) :: Ratio a -> Ratio a -> Ratio a Source #

zero :: Ratio a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Subtractive (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

negate :: Ratio a -> Ratio a Source #

(-) :: Ratio a -> Ratio a -> Ratio a Source #

(Ord a, EndoBased a, Absolute a, ToInt a, Integral a, Ring a) => QuotientField (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Associated Types

type Whole (Ratio a)
Instance details Defined in NumHask.Data.Rational type Whole (Ratio a) = Int

Methods

properFraction :: Ratio a -> (Whole (Ratio a), Ratio a) Source #

round :: Ratio a -> Whole (Ratio a) Source #

ceiling :: Ratio a -> Whole (Ratio a) Source #

floor :: Ratio a -> Whole (Ratio a) Source #

truncate :: Ratio a -> Whole (Ratio a) Source #

(Ord a, Integral a, EndoBased a, Subtractive a) => JoinSemiLattice (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

(\/) :: Ratio a -> Ratio a -> Ratio a Source #

(Ord a, Integral a, EndoBased a, Subtractive a) => MeetSemiLattice (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

(/\) :: Ratio a -> Ratio a -> Ratio a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Basis (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Associated Types

type Mag (Ratio a)
Instance details Defined in NumHask.Data.Rational type Mag (Ratio a) = Ratio a
type Base (Ratio a)
Instance details Defined in NumHask.Data.Rational type Base (Ratio a) = Ratio a

Methods

magnitude :: Ratio a -> Mag (Ratio a) Source #

basis :: Ratio a -> Base (Ratio a) Source #

(Ord a, EndoBased a, Integral a, Ring a, MeetSemiLattice a) => Epsilon (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

epsilon :: Ratio a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Divisive (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

recip :: Ratio a -> Ratio a Source #

(/) :: Ratio a -> Ratio a -> Ratio a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Multiplicative (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

(*) :: Ratio a -> Ratio a -> Ratio a Source #

one :: Ratio a Source #

FromRational (Ratio Integer) Source #

Instance details

Defined in NumHask.Data.Rational

Methods

fromRational :: Rational -> Ratio Integer Source #

(FromIntegral a b, Multiplicative a) => FromIntegral (Ratio a) b Source #

Instance details

Defined in NumHask.Data.Rational

Methods

fromIntegral :: b -> Ratio a Source #

ToRatio (Ratio Integer) Integer Source #

Instance details

Defined in NumHask.Data.Rational

Methods

toRatio :: Ratio Integer -> Ratio Integer Source #

type Whole (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

type Whole (Ratio a) = Int

type Base (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

type Base (Ratio a) = Ratio a

type Mag (Ratio a) Source #

Instance details

Defined in NumHask.Data.Rational

type Mag (Ratio a) = Ratio a

type Rational = Ratio Integer Source #

Ratio of two integers

class ToRatio a b where Source #

toRatio is equivalent to Real in base, but is polymorphic in the Integral type.

>>> toRatio (3.1415927 :: Float) :: Ratio Integer
13176795 :% 4194304

Methods

toRatio :: a -> Ratio b Source #

Instances

Instances details

ToRatio Int16 Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Int16 -> Ratio Integer Source #
ToRatio Int32 Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Int32 -> Ratio Integer Source #
ToRatio Int64 Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Int64 -> Ratio Integer Source #
ToRatio Int8 Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Int8 -> Ratio Integer Source #
ToRatio Word16 Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Word16 -> Ratio Integer Source #
ToRatio Word32 Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Word32 -> Ratio Integer Source #
ToRatio Word64 Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Word64 -> Ratio Integer Source #
ToRatio Word8 Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Word8 -> Ratio Integer Source #
ToRatio Integer Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Integer -> Ratio Integer Source #
ToRatio Natural Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Natural -> Ratio Integer Source #
ToRatio Double Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Double -> Ratio Integer Source #
ToRatio Float Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Float -> Ratio Integer Source #
ToRatio Int Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Int -> Ratio Integer Source #
ToRatio Word Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Word -> Ratio Integer Source #
ToRatio a b => ToRatio (Positive a) b Source #
Instance details Defined in NumHask.Data.Positive Methods toRatio :: Positive a -> Ratio b Source #
ToRatio (Ratio Integer) Integer Source #
Instance details Defined in NumHask.Data.Rational Methods toRatio :: Ratio Integer -> Ratio Integer Source #
ToRatio a b => ToRatio (Wrapped a) b Source #
Instance details Defined in NumHask.Data.Wrapped Methods toRatio :: Wrapped a -> Ratio b Source #

class FromRatio a b where Source #

Fractional in base splits into fromRatio and Field

>>> fromRatio (5 :% 2 :: Ratio Integer) :: Double
2.5

Methods

fromRatio :: Ratio b -> a Source #

Instances

Instances details

FromRatio Rational Integer Source #
Instance details Defined in NumHask.Data.Rational Methods fromRatio :: Ratio Integer -> Rational Source #
FromRatio Double Integer Source #
Instance details Defined in NumHask.Data.Rational Methods fromRatio :: Ratio Integer -> Double Source #
FromRatio Float Integer Source #
Instance details Defined in NumHask.Data.Rational Methods fromRatio :: Ratio Integer -> Float Source #
FromRatio a b => FromRatio (Positive a) b Source #
Instance details Defined in NumHask.Data.Positive Methods fromRatio :: Ratio b -> Positive a Source #
FromRatio a b => FromRatio (Wrapped a) b Source #
Instance details Defined in NumHask.Data.Wrapped Methods fromRatio :: Ratio b -> Wrapped a Source #

class FromRational a where Source #

fromRational is special in two ways:

numeric decimal literals (like "53.66") are interpreted as exactly "fromRational (53.66 :: GHC.Real.Ratio Integer)". The prelude version, GHC.Real.fromRational is used as default (or whatever is in scope if RebindableSyntax is set).
The default rules in haskell2010 specify that contraints on fromRational need to be in a form C v, where v is a Num or a subclass of Num.

So a type synonym of `type FromRational a = FromRatio a Integer` doesn't work well with type defaulting; hence the need for a separate class.

Methods

fromRational :: Rational -> a Source #

Instances

Instances details

FromRational Double Source #
Instance details Defined in NumHask.Data.Rational Methods fromRational :: Rational -> Double Source #
FromRational Float Source #
Instance details Defined in NumHask.Data.Rational Methods fromRational :: Rational -> Float Source #
FromRational a => FromRational (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods fromRational :: Rational -> Positive a Source #
FromRational (Ratio Integer) Source #
Instance details Defined in NumHask.Data.Rational Methods fromRational :: Rational -> Ratio Integer Source #
FromRational a => FromRational (Wrapped a) Source #
Instance details Defined in NumHask.Data.Wrapped Methods fromRational :: Rational -> Wrapped a Source #

reduce :: (Eq a, Subtractive a, EndoBased a, Integral a) => a -> a -> Ratio a Source #

reduce normalises a ratio by dividing both numerator and denominator by their greatest common divisor.

>>> reduce 72 60
6 :% 5

\a b -> reduce a b == a :% b || b == zero

gcd :: (Eq a, EndoBased a, Integral a) => a -> a -> a Source #

gcd x y is the non-negative factor of both x and y of which every common factor of x and y is also a factor; for example gcd 4 2 = 2, gcd (-4) 6 = 2, gcd 0 4 = 4. gcd 0 0 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)

Note: Since for signed fixed-width integer types, abs minBound < 0, the result may be negative if one of the arguments is minBound (and necessarily is if the other is 0 or minBound) for such types.

>>> gcd 72 60
12

Exceptions

newtype NumHaskException Source #

A numhask exception.

Constructors

NumHaskException
Fields errorMessage :: String

Instances

Instances details

Exception NumHaskException Source #
Instance details Defined in NumHask.Exception Methods toException :: NumHaskException -> SomeException # fromException :: SomeException -> Maybe NumHaskException # displayException :: NumHaskException -> String # backtraceDesired :: NumHaskException -> Bool #
Show NumHaskException Source #
Instance details Defined in NumHask.Exception Methods showsPrec :: Int -> NumHaskException -> ShowS # show :: NumHaskException -> String # showList :: [NumHaskException] -> ShowS #

throw :: forall a e. (HasCallStack, Exception e) => e -> a #

Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad.

WARNING: You may want to use throwIO instead so that your pure code stays exception-free.