NumHask.Data.Positive

A positive number type, defined as existing on [zero, +infinity)

Documentation

newtype Positive a

A positive number is a number that is contained in [zero,+infinity).

>>> 1 :: Positive Int
UnsafePositive {unPositive = 1}

>>> -1 :: Positive Int
...
    • No instance for ‘Subtractive (Positive Int)’
        arising from a use of syntactic negation
...

zero is positive

>>> positive 0 == zero
True

The main constructors:

>>> positive (-1)
UnsafePositive {unPositive = 0}

>>> maybePositive (-1)
Nothing

>>> UnsafePositive (-1)
UnsafePositive {unPositive = -1}

Constructors

UnsafePositive

Fields

• unPositive :: a

Instances

Show a => Show (Positive a)

Defined in NumHask.Data.Positive

Methods

showsPrec :: Int -> Positive a -> ShowS

show :: Positive a -> String

showList :: [Positive a] -> ShowS

Eq a => Eq (Positive a)

Defined in NumHask.Data.Positive

Methods

(==) :: Positive a -> Positive a -> Bool

(/=) :: Positive a -> Positive a -> Bool

Ord a => Ord (Positive a)

Defined in NumHask.Data.Positive

Methods

compare :: Positive a -> Positive a -> Ordering

(<) :: Positive a -> Positive a -> Bool

(<=) :: Positive a -> Positive a -> Bool

(>) :: Positive a -> Positive a -> Bool

(>=) :: Positive a -> Positive a -> Bool

max :: Positive a -> Positive a -> Positive a

min :: Positive a -> Positive a -> Positive a

AdditiveAction a => AdditiveAction (Positive a)

Defined in NumHask.Data.Positive

Associated Types

type AdditiveScalar (Positive a)

Methods

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

DivisiveAction a => DivisiveAction (Positive a)

Defined in NumHask.Data.Positive

Methods

(|/) :: Positive a -> Scalar (Positive a) -> Positive a

MultiplicativeAction a => MultiplicativeAction (Positive a)

Defined in NumHask.Data.Positive

Associated Types

type Scalar (Positive a)

Methods

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

SubtractiveAction a => SubtractiveAction (Positive a)

Defined in NumHask.Data.Positive

Methods

(|-) :: Positive a -> AdditiveScalar (Positive a) -> Positive a

Additive a => Additive (Positive a)

Defined in NumHask.Data.Positive

Methods

(+) :: Positive a -> Positive a -> Positive a

zero :: Positive a

QuotientField (Positive Double)

Defined in NumHask.Data.Positive

Associated Types

type Whole (Positive Double)

Methods

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

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

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

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

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

(Additive a, JoinSemiLattice a) => BoundedJoinSemiLattice (Positive a)

Defined in NumHask.Data.Positive

Methods

bottom :: Positive a

BoundedMeetSemiLattice a => BoundedMeetSemiLattice (Positive a)

Defined in NumHask.Data.Positive

Methods

top :: Positive a

JoinSemiLattice a => JoinSemiLattice (Positive a)

Defined in NumHask.Data.Positive

Methods

(\/) :: Positive a -> Positive a -> Positive a

MeetSemiLattice a => MeetSemiLattice (Positive a)

Defined in NumHask.Data.Positive

Methods

(/\) :: Positive a -> Positive a -> Positive a

Basis a => Basis (Positive a)

Defined in NumHask.Data.Positive

Associated Types

type Mag (Positive a)

type Base (Positive a)

Methods

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

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

Direction a => Direction (Positive a)

Defined in NumHask.Data.Positive

Associated Types

type Dir (Positive a)

Methods

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

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

Epsilon a => Epsilon (Positive a)

Defined in NumHask.Data.Positive

Methods

epsilon :: Positive a

Divisive a => Divisive (Positive a)

Defined in NumHask.Data.Positive

Methods

recip :: Positive a -> Positive a

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

Multiplicative a => Multiplicative (Positive a)

Defined in NumHask.Data.Positive

Methods

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

one :: Positive a

FromInteger a => FromInteger (Positive a)

Defined in NumHask.Data.Positive

Methods

fromInteger :: Integer -> Positive a

Integral a => Integral (Positive a)

Defined in NumHask.Data.Positive

Methods

div :: Positive a -> Positive a -> Positive a

mod :: Positive a -> Positive a -> Positive a

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

quot :: Positive a -> Positive a -> Positive a

rem :: Positive a -> Positive a -> Positive a

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

(Subtractive a, MeetSemiLattice a) => Monus (Positive a)

Defined in NumHask.Data.Positive

Methods

(∸) :: Positive a -> Positive a -> Positive a

FromRational a => FromRational (Positive a)

Defined in NumHask.Data.Positive

Methods

fromRational :: Rational -> Positive a

(MeetSemiLattice a, Integral a) => FromIntegral (Positive a) a

Defined in NumHask.Data.Positive

Methods

fromIntegral :: a -> Positive a

FromIntegral a b => FromIntegral (Positive a) b

Defined in NumHask.Data.Positive

Methods

fromIntegral :: b -> Positive a

ToIntegral a b => ToIntegral (Positive a) b

Defined in NumHask.Data.Positive

Methods

toIntegral :: Positive a -> b

FromRatio a b => FromRatio (Positive a) b

Defined in NumHask.Data.Positive

Methods

fromRatio :: Ratio b -> Positive a

ToRatio a b => ToRatio (Positive a) b

Defined in NumHask.Data.Positive

Methods

toRatio :: Positive a -> Ratio b

type AdditiveScalar (Positive a)

Defined in NumHask.Data.Positive

type AdditiveScalar (Positive a) = AdditiveScalar (Wrapped a)

type Scalar (Positive a)

Defined in NumHask.Data.Positive

type Scalar (Positive a) = Scalar (Wrapped a)

type Whole (Positive Double)

Defined in NumHask.Data.Positive

type Whole (Positive Double) = Positive Int

type Base (Positive a)

Defined in NumHask.Data.Positive

type Base (Positive a) = Base (Wrapped a)

type Dir (Positive a)

Defined in NumHask.Data.Positive

type Dir (Positive a) = Dir (Wrapped a)

type Mag (Positive a)

Defined in NumHask.Data.Positive

type Mag (Positive a) = Mag (Wrapped a)

positive :: (Additive a, MeetSemiLattice a) => a -> Positive a

Constructor which returns zero for a negative number.

>>> positive (-1)
UnsafePositive {unPositive = 0}

maybePositive :: (Additive a, MeetSemiLattice a) => a -> Maybe (Positive a)

Constructor which returns Nothing if a negative number is supplied.

>>> maybePositive (-one)
Nothing

positive_ :: a -> Positive a

Unsafe constructor.

>>> positive_ (-one)
UnsafePositive {unPositive = -1}

class Monus a where

Monus or truncated subtraction.

>>> positive 4 ∸ positive 7
UnsafePositive {unPositive = 0}

>>> 4 ∸ 7 :: Positive Int
UnsafePositive {unPositive = 0}

Since: 0.12

Minimal complete definition

(∸)

Methods

(∸) :: a -> a -> a infixl 6

default (∸) :: (BoundedJoinSemiLattice a, MeetSemiLattice a, Subtractive a) => a -> a -> a

Instances

(Subtractive a, MeetSemiLattice a) => Monus (Positive a)

Defined in NumHask.Data.Positive

Methods

(∸) :: Positive a -> Positive a -> Positive a

class Addus a where

Truncated addition

Since: 0.12

Minimal complete definition

(∔)

Methods

(∔) :: a -> a -> a infixl 6

default (∔) :: (BoundedMeetSemiLattice a, JoinSemiLattice a, Additive a) => a -> a -> a

type MonusSemiField a = (Monus a, Distributive a, Divisive a)

A field but with truncated subtraction.