Numeric.MixedTypes.Ring

Ring

type CanAddSubMulBy t s = (CanAddThis t s, CanSubThis t s, CanMulBy t s)

type Ring t = (CanNegSameType t, CanAddSameType t, CanSubSameType t, CanMulSameType t, CanPowBy t Integer, CanPowBy t Int, HasEq t t, HasEq t Integer, CanAddSubMulBy t Integer, CanSub Integer t, SubType Integer t ~ t, HasEq t Int, CanAddSubMulBy t Int, CanSub Int t, SubType Int t ~ t, ConvertibleExactly Integer t)

type CertainlyEqRing t = (Ring t, HasEqCertainly t t, HasEqCertainly t Int, HasEqCertainly t Integer)

type OrderedRing t = (Ring t, HasOrder t t, HasOrder t Int, HasOrder t Integer)

type OrderedCertainlyRing t = (CertainlyEqRing t, HasOrderCertainly t t, HasOrderCertainly t Int, HasOrderCertainly t Integer, CanTestPosNeg t)

Multiplication

type CanMul t1 t2 = (CanMulAsymmetric t1 t2, CanMulAsymmetric t2 t1, MulType t1 t2 ~ MulType t2 t1)

class CanMulAsymmetric t1 t2 where

A replacement for Prelude's *. If t1 = t2 and Num t1, then one can use the default implementation to mirror Prelude's *.

Associated Types

type MulType t1 t2

Methods

mul :: t1 -> t2 -> MulType t1 t2

mul :: (MulType t1 t2 ~ t1, t1 ~ t2, Num t1) => t1 -> t1 -> t1

Instances

CanMulAsymmetric Double Double

Associated Types

type MulType Double Double :: *

Methods

mul :: Double -> Double -> MulType Double Double

CanMulAsymmetric Double Int

Associated Types

type MulType Double Int :: *

Methods

mul :: Double -> Int -> MulType Double Int

CanMulAsymmetric Double Integer

Associated Types

type MulType Double Integer :: *

Methods

mul :: Double -> Integer -> MulType Double Integer

CanMulAsymmetric Double Rational

Associated Types

type MulType Double Rational :: *

Methods

mul :: Double -> Rational -> MulType Double Rational

CanMulAsymmetric Int Double

Associated Types

type MulType Int Double :: *

Methods

mul :: Int -> Double -> MulType Int Double

CanMulAsymmetric Int Int

Associated Types

type MulType Int Int :: *

Methods

mul :: Int -> Int -> MulType Int Int

CanMulAsymmetric Int Integer

Associated Types

type MulType Int Integer :: *

Methods

mul :: Int -> Integer -> MulType Int Integer

CanMulAsymmetric Int Rational

Associated Types

type MulType Int Rational :: *

Methods

mul :: Int -> Rational -> MulType Int Rational

CanMulAsymmetric Integer Double

Associated Types

type MulType Integer Double :: *

Methods

mul :: Integer -> Double -> MulType Integer Double

CanMulAsymmetric Integer Int

Associated Types

type MulType Integer Int :: *

Methods

mul :: Integer -> Int -> MulType Integer Int

CanMulAsymmetric Integer Integer

Associated Types

type MulType Integer Integer :: *

Methods

mul :: Integer -> Integer -> MulType Integer Integer

CanMulAsymmetric Integer Rational

Associated Types

type MulType Integer Rational :: *

Methods

mul :: Integer -> Rational -> MulType Integer Rational

CanMulAsymmetric Rational Double

Associated Types

type MulType Rational Double :: *

Methods

mul :: Rational -> Double -> MulType Rational Double

CanMulAsymmetric Rational Int

Associated Types

type MulType Rational Int :: *

Methods

mul :: Rational -> Int -> MulType Rational Int

CanMulAsymmetric Rational Integer

Associated Types

type MulType Rational Integer :: *

Methods

mul :: Rational -> Integer -> MulType Rational Integer

CanMulAsymmetric Rational Rational

Associated Types

type MulType Rational Rational :: *

Methods

mul :: Rational -> Rational -> MulType Rational Rational

CanMulAsymmetric a b => CanMulAsymmetric [a] [b]

Associated Types

type MulType [a] [b] :: *

Methods

mul :: [a] -> [b] -> MulType [a] [b]

CanMulAsymmetric a b => CanMulAsymmetric (Maybe a) (Maybe b)

Associated Types

type MulType (Maybe a) (Maybe b) :: *

Methods

mul :: Maybe a -> Maybe b -> MulType (Maybe a) (Maybe b)

type CanMulBy t1 t2 = (CanMul t1 t2, MulType t1 t2 ~ t1)

type CanMulSameType t = CanMulBy t t

(*) :: CanMulAsymmetric t1 t2 => t1 -> t2 -> MulType t1 t2 infixl 7

product :: (CanMulSameType t, ConvertibleExactly Integer t) => [t] -> t

Tests

specCanMul :: (CanMulX t1 t2, CanMulX t1 t3, CanMulX t2 t3, CanMulX t1 (MulType t2 t3), CanMulX (MulType t1 t2) t3, HasEqCertainly (MulType t1 (MulType t2 t3)) (MulType (MulType t1 t2) t3), CanAdd t2 t3, CanMulX t1 (AddType t2 t3), CanAddX (MulType t1 t2) (MulType t1 t3), HasEqCertainly (MulType t1 (AddType t2 t3)) (AddType (MulType t1 t2) (MulType t1 t3)), ConvertibleExactly Integer t2) => T t1 -> T t2 -> T t3 -> Spec

HSpec properties that each implementation of CanMul should satisfy.

specCanMulNotMixed :: (CanMulX t t, CanMulX t (MulType t t), HasEqCertainly (MulType (MulType t t) t) (MulType t (MulType t t)), CanAdd t t, CanMulX t (AddType t t), CanAddX (MulType t t) (MulType t t), HasEqCertainly (MulType t (AddType t t)) (AddType (MulType t t) (MulType t t)), ConvertibleExactly Integer t) => T t -> Spec

HSpec properties that each implementation of CanMul should satisfy.

specCanMulSameType :: (ConvertibleExactly Integer t, Show t, HasEqCertainly t t, CanMulSameType t) => T t -> Spec

HSpec properties that each implementation of CanMulSameType should satisfy.

type CanMulX t1 t2 = (CanMul t1 t2, Show t1, Arbitrary t1, Show t2, Arbitrary t2, Show (MulType t1 t2), HasEqCertainly t1 (MulType t1 t2), HasEqCertainly t2 (MulType t1 t2), HasEqCertainly (MulType t1 t2) (MulType t1 t2), HasOrderCertainly t1 (MulType t1 t2), HasOrderCertainly t2 (MulType t1 t2), HasOrderCertainly (MulType t1 t2) (MulType t1 t2))

Compound type constraint useful for test definition.

Exponentiation

class CanPow t1 t2 where

A replacement for Prelude's binary ^ and ^^. If Num t1 and Integral t2, then one can use the default implementation to mirror Prelude's ^.

Associated Types

type PowType t1 t2

Methods

pow :: t1 -> t2 -> PowType t1 t2

pow :: (PowType t1 t2 ~ t1, Num t1, Integral t2) => t1 -> t2 -> t1

Instances

CanPow Double Int

Associated Types

type PowType Double Int :: *

Methods

pow :: Double -> Int -> PowType Double Int

CanPow Double Integer

Associated Types

type PowType Double Integer :: *

Methods

pow :: Double -> Integer -> PowType Double Integer

CanPow Int Int

Associated Types

type PowType Int Int :: *

Methods

pow :: Int -> Int -> PowType Int Int

CanPow Int Integer

Associated Types

type PowType Int Integer :: *

Methods

pow :: Int -> Integer -> PowType Int Integer

CanPow Integer Int

Associated Types

type PowType Integer Int :: *

Methods

pow :: Integer -> Int -> PowType Integer Int

CanPow Integer Integer

Associated Types

type PowType Integer Integer :: *

Methods

pow :: Integer -> Integer -> PowType Integer Integer

CanPow Rational Int

Associated Types

type PowType Rational Int :: *

Methods

pow :: Rational -> Int -> PowType Rational Int

CanPow Rational Integer

Associated Types

type PowType Rational Integer :: *

Methods

pow :: Rational -> Integer -> PowType Rational Integer

CanPow a b => CanPow (Maybe a) (Maybe b)

Associated Types

type PowType (Maybe a) (Maybe b) :: *

Methods

pow :: Maybe a -> Maybe b -> PowType (Maybe a) (Maybe b)

type CanPowBy t1 t2 = (CanPow t1 t2, PowType t1 t2 ~ t1)

(^) :: CanPow t1 t2 => t1 -> t2 -> PowType t1 t2 infixl 8

(^^) :: CanPow t1 t2 => t1 -> t2 -> PowType t1 t2 infixl 8

A synonym of ^

(**) :: CanPow t1 t2 => t1 -> t2 -> PowType t1 t2

A synonym of ^

powUsingMul :: (CanBeInteger e, CanMulSameType t, ConvertibleExactly Integer t) => t -> e -> t

Tests

specCanPow :: (CanPowX t1 t2, HasEqCertainly t1 (PowType t1 t2), ConvertibleExactly Integer t1, ConvertibleExactly Integer t2, CanTestPosNeg t2, CanAdd t2 Integer, CanMulX t1 (PowType t1 t2), CanPowX t1 (AddType t2 Integer), HasEqCertainly (MulType t1 (PowType t1 t2)) (PowType t1 (AddType t2 Integer))) => T t1 -> T t2 -> Spec

HSpec properties that each implementation of CanPow should satisfy.

type CanPowX t1 t2 = (CanPow t1 t2, Show t1, Arbitrary t1, Show t2, Arbitrary t2, Show (PowType t1 t2))

Compound type constraint useful for test definition.