Numeric.ProductOrd.NonTransitive

Compare product types using non-transitive Ord instances:

• \( a = b \) and \( b = c \) does not mean \( a = c \);
• but, if nor \( a > b \) neither \( b > a \), then \( a = b \).

To remind yourself that ProductOrd is not fully faithful, you may import it qualified, e.g.

 import qualified Numeric.ProductOrd.NonTransitive as NonTransitive

Documentation

newtype ProductOrd a

Redefine Ord instance for a type which is a cartesian product -- as a partial product order.

Since vanilla Haskell Ord class is always about total order, ProductOrd instance is not particularly correct. However, it turns out to be very useful for comparing vector or tuple-like types.

The implementation of ProductOrd in this module workarounds this by using a non-transitive Eq instance: \[ a = b \iff \neg (a > b) \land \neg (b > a) \]

Another inconsistency with the Haskell Report is the min and max functions; these are simply element-wise minimum and maximum here. Thus, these instances preserve important properties like min a b <= a && min a b <= b, but do not preserve a property that min a b == a || min a b == b.

All of this is really useful in geometry applications and for calculating things like Pareto dominance, but should be used with care. Remember about this if you want to put a ProductOrd into a Set or a Map!

Constructors

ProductOrd

Fields

• getProductOrd :: a

Instances

Monad ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

Methods

(>>=) :: ProductOrd a -> (a -> ProductOrd b) -> ProductOrd b

(>>) :: ProductOrd a -> ProductOrd b -> ProductOrd b

return :: a -> ProductOrd a

Functor ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

Methods

fmap :: (a -> b) -> ProductOrd a -> ProductOrd b

(<$) :: a -> ProductOrd b -> ProductOrd a

MonadFix ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

Methods

mfix :: (a -> ProductOrd a) -> ProductOrd a

Applicative ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

Methods

pure :: a -> ProductOrd a

(<*>) :: ProductOrd (a -> b) -> ProductOrd a -> ProductOrd b

liftA2 :: (a -> b -> c) -> ProductOrd a -> ProductOrd b -> ProductOrd c

(*>) :: ProductOrd a -> ProductOrd b -> ProductOrd b

(<*) :: ProductOrd a -> ProductOrd b -> ProductOrd a

Foldable ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

Methods

fold :: Monoid m => ProductOrd m -> m

foldMap :: Monoid m => (a -> m) -> ProductOrd a -> m

foldMap' :: Monoid m => (a -> m) -> ProductOrd a -> m

foldr :: (a -> b -> b) -> b -> ProductOrd a -> b

foldr' :: (a -> b -> b) -> b -> ProductOrd a -> b

foldl :: (b -> a -> b) -> b -> ProductOrd a -> b

foldl' :: (b -> a -> b) -> b -> ProductOrd a -> b

foldr1 :: (a -> a -> a) -> ProductOrd a -> a

foldl1 :: (a -> a -> a) -> ProductOrd a -> a

toList :: ProductOrd a -> [a]

null :: ProductOrd a -> Bool

length :: ProductOrd a -> Int

elem :: Eq a => a -> ProductOrd a -> Bool

maximum :: Ord a => ProductOrd a -> a

minimum :: Ord a => ProductOrd a -> a

sum :: Num a => ProductOrd a -> a

product :: Num a => ProductOrd a -> a

Traversable ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

Methods

traverse :: Applicative f => (a -> f b) -> ProductOrd a -> f (ProductOrd b)

sequenceA :: Applicative f => ProductOrd (f a) -> f (ProductOrd a)

mapM :: Monad m => (a -> m b) -> ProductOrd a -> m (ProductOrd b)

sequence :: Monad m => ProductOrd (m a) -> m (ProductOrd a)

MonadZip ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

Methods

mzip :: ProductOrd a -> ProductOrd b -> ProductOrd (a, b)

mzipWith :: (a -> b -> c) -> ProductOrd a -> ProductOrd b -> ProductOrd c

munzip :: ProductOrd (a, b) -> (ProductOrd a, ProductOrd b)

Bounded a => Bounded (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

minBound :: ProductOrd a

maxBound :: ProductOrd a

Enum a => Enum (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

succ :: ProductOrd a -> ProductOrd a

pred :: ProductOrd a -> ProductOrd a

toEnum :: Int -> ProductOrd a

fromEnum :: ProductOrd a -> Int

enumFrom :: ProductOrd a -> [ProductOrd a]

enumFromThen :: ProductOrd a -> ProductOrd a -> [ProductOrd a]

enumFromTo :: ProductOrd a -> ProductOrd a -> [ProductOrd a]

enumFromThenTo :: ProductOrd a -> ProductOrd a -> ProductOrd a -> [ProductOrd a]

Ord (ProductOrd a) => Eq (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

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

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

Floating a => Floating (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

pi :: ProductOrd a

exp :: ProductOrd a -> ProductOrd a

log :: ProductOrd a -> ProductOrd a

sqrt :: ProductOrd a -> ProductOrd a

(**) :: ProductOrd a -> ProductOrd a -> ProductOrd a

logBase :: ProductOrd a -> ProductOrd a -> ProductOrd a

sin :: ProductOrd a -> ProductOrd a

cos :: ProductOrd a -> ProductOrd a

tan :: ProductOrd a -> ProductOrd a

asin :: ProductOrd a -> ProductOrd a

acos :: ProductOrd a -> ProductOrd a

atan :: ProductOrd a -> ProductOrd a

sinh :: ProductOrd a -> ProductOrd a

cosh :: ProductOrd a -> ProductOrd a

tanh :: ProductOrd a -> ProductOrd a

asinh :: ProductOrd a -> ProductOrd a

acosh :: ProductOrd a -> ProductOrd a

atanh :: ProductOrd a -> ProductOrd a

log1p :: ProductOrd a -> ProductOrd a

expm1 :: ProductOrd a -> ProductOrd a

log1pexp :: ProductOrd a -> ProductOrd a

log1mexp :: ProductOrd a -> ProductOrd a

Fractional a => Fractional (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

(/) :: ProductOrd a -> ProductOrd a -> ProductOrd a

recip :: ProductOrd a -> ProductOrd a

fromRational :: Rational -> ProductOrd a

(Ord (ProductOrd a), Integral a) => Integral (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

quot :: ProductOrd a -> ProductOrd a -> ProductOrd a

rem :: ProductOrd a -> ProductOrd a -> ProductOrd a

div :: ProductOrd a -> ProductOrd a -> ProductOrd a

mod :: ProductOrd a -> ProductOrd a -> ProductOrd a

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

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

toInteger :: ProductOrd a -> Integer

Data a => Data (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

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

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

toConstr :: ProductOrd a -> Constr

dataTypeOf :: ProductOrd a -> DataType

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

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

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

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

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

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

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

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

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

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

Num a => Num (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

(+) :: ProductOrd a -> ProductOrd a -> ProductOrd a

(-) :: ProductOrd a -> ProductOrd a -> ProductOrd a

(*) :: ProductOrd a -> ProductOrd a -> ProductOrd a

negate :: ProductOrd a -> ProductOrd a

abs :: ProductOrd a -> ProductOrd a

signum :: ProductOrd a -> ProductOrd a

fromInteger :: Integer -> ProductOrd a

(Ord a1, Ord a2) => Ord (ProductOrd (a1, a2))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (a1, a2) -> ProductOrd (a1, a2) -> Ordering

(<) :: ProductOrd (a1, a2) -> ProductOrd (a1, a2) -> Bool

(<=) :: ProductOrd (a1, a2) -> ProductOrd (a1, a2) -> Bool

(>) :: ProductOrd (a1, a2) -> ProductOrd (a1, a2) -> Bool

(>=) :: ProductOrd (a1, a2) -> ProductOrd (a1, a2) -> Bool

max :: ProductOrd (a1, a2) -> ProductOrd (a1, a2) -> ProductOrd (a1, a2)

min :: ProductOrd (a1, a2) -> ProductOrd (a1, a2) -> ProductOrd (a1, a2)

(Ord a1, Ord a2, Ord a3) => Ord (ProductOrd (a1, a2, a3))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3) -> Ordering

(<) :: ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3) -> Bool

(<=) :: ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3) -> Bool

(>) :: ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3) -> Bool

(>=) :: ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3) -> Bool

max :: ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3)

min :: ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3) -> ProductOrd (a1, a2, a3)

(Ord a1, Ord a2, Ord a3, Ord a4) => Ord (ProductOrd (a1, a2, a3, a4))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4) -> Ordering

(<) :: ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4) -> Bool

(<=) :: ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4) -> Bool

(>) :: ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4) -> Bool

(>=) :: ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4) -> Bool

max :: ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4)

min :: ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4) -> ProductOrd (a1, a2, a3, a4)

(Ord a1, Ord a2, Ord a3, Ord a4, Ord a5) => Ord (ProductOrd (a1, a2, a3, a4, a5))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5) -> Ordering

(<) :: ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5) -> Bool

(<=) :: ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5) -> Bool

(>) :: ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5) -> Bool

(>=) :: ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5) -> Bool

max :: ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5)

min :: ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5) -> ProductOrd (a1, a2, a3, a4, a5)

(Ord a1, Ord a2, Ord a3, Ord a4, Ord a5, Ord a6) => Ord (ProductOrd (a1, a2, a3, a4, a5, a6))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6) -> Ordering

(<) :: ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6) -> Bool

(<=) :: ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6) -> Bool

(>) :: ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6) -> Bool

(>=) :: ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6) -> Bool

max :: ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6)

min :: ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6) -> ProductOrd (a1, a2, a3, a4, a5, a6)

(Ord a1, Ord a2, Ord a3, Ord a4, Ord a5, Ord a6, Ord a7) => Ord (ProductOrd (a1, a2, a3, a4, a5, a6, a7))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> Ordering

(<) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> Bool

(<=) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> Bool

(>) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> Bool

(>=) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> Bool

max :: ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7)

min :: ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7)

(Ord a1, Ord a2, Ord a3, Ord a4, Ord a5, Ord a6, Ord a7, Ord a8) => Ord (ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> Ordering

(<) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> Bool

(<=) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> Bool

(>) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> Bool

(>=) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> Bool

max :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8)

min :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8)

(Ord a1, Ord a2, Ord a3, Ord a4, Ord a5, Ord a6, Ord a7, Ord a8, Ord a9) => Ord (ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Ordering

(<) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Bool

(<=) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Bool

(>) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Bool

(>=) :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Bool

max :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9)

min :: ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9)

All Ord (Map f xs) => Ord (ProductOrd (TypedList f xs))

Defined in Numeric.ProductOrd.NonTransitive

Methods

compare :: ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs) -> Ordering

(<) :: ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs) -> Bool

(<=) :: ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs) -> Bool

(>) :: ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs) -> Bool

(>=) :: ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs) -> Bool

max :: ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs)

min :: ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs) -> ProductOrd (TypedList f xs)

Ord (ProductOrd (DFBackend t ds)) => Ord (ProductOrd (DataFrame t ds))

Defined in Numeric.DataFrame.Type

Methods

compare :: ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds) -> Ordering

(<) :: ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds) -> Bool

(<=) :: ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds) -> Bool

(>) :: ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds) -> Bool

(>=) :: ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds) -> Bool

max :: ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds)

min :: ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds) -> ProductOrd (DataFrame t ds)

Read a => Read (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

readsPrec :: Int -> ReadS (ProductOrd a)

readList :: ReadS [ProductOrd a]

readPrec :: ReadPrec (ProductOrd a)

readListPrec :: ReadPrec [ProductOrd a]

(Ord (ProductOrd a), Real a) => Real (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

toRational :: ProductOrd a -> Rational

(Ord (ProductOrd a), RealFloat a) => RealFloat (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

floatRadix :: ProductOrd a -> Integer

floatDigits :: ProductOrd a -> Int

floatRange :: ProductOrd a -> (Int, Int)

decodeFloat :: ProductOrd a -> (Integer, Int)

encodeFloat :: Integer -> Int -> ProductOrd a

exponent :: ProductOrd a -> Int

significand :: ProductOrd a -> ProductOrd a

scaleFloat :: Int -> ProductOrd a -> ProductOrd a

isNaN :: ProductOrd a -> Bool

isInfinite :: ProductOrd a -> Bool

isDenormalized :: ProductOrd a -> Bool

isNegativeZero :: ProductOrd a -> Bool

isIEEE :: ProductOrd a -> Bool

atan2 :: ProductOrd a -> ProductOrd a -> ProductOrd a

(Ord (ProductOrd a), RealFrac a) => RealFrac (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

properFraction :: Integral b => ProductOrd a -> (b, ProductOrd a)

truncate :: Integral b => ProductOrd a -> b

round :: Integral b => ProductOrd a -> b

ceiling :: Integral b => ProductOrd a -> b

floor :: Integral b => ProductOrd a -> b

Show a => Show (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

showsPrec :: Int -> ProductOrd a -> ShowS

show :: ProductOrd a -> String

showList :: [ProductOrd a] -> ShowS

Generic (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Associated Types

type Rep (ProductOrd a) :: Type -> Type

Methods

from :: ProductOrd a -> Rep (ProductOrd a) x

to :: Rep (ProductOrd a) x -> ProductOrd a

Semigroup a => Semigroup (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

(<>) :: ProductOrd a -> ProductOrd a -> ProductOrd a

sconcat :: NonEmpty (ProductOrd a) -> ProductOrd a

stimes :: Integral b => b -> ProductOrd a -> ProductOrd a

Monoid a => Monoid (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

mempty :: ProductOrd a

mappend :: ProductOrd a -> ProductOrd a -> ProductOrd a

mconcat :: [ProductOrd a] -> ProductOrd a

Storable a => Storable (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

sizeOf :: ProductOrd a -> Int

alignment :: ProductOrd a -> Int

peekElemOff :: Ptr (ProductOrd a) -> Int -> IO (ProductOrd a)

pokeElemOff :: Ptr (ProductOrd a) -> Int -> ProductOrd a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (ProductOrd a)

pokeByteOff :: Ptr b -> Int -> ProductOrd a -> IO ()

peek :: Ptr (ProductOrd a) -> IO (ProductOrd a)

poke :: Ptr (ProductOrd a) -> ProductOrd a -> IO ()

(Ord (ProductOrd a), Bits a) => Bits (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

(.&.) :: ProductOrd a -> ProductOrd a -> ProductOrd a

(.|.) :: ProductOrd a -> ProductOrd a -> ProductOrd a

xor :: ProductOrd a -> ProductOrd a -> ProductOrd a

complement :: ProductOrd a -> ProductOrd a

shift :: ProductOrd a -> Int -> ProductOrd a

rotate :: ProductOrd a -> Int -> ProductOrd a

zeroBits :: ProductOrd a

bit :: Int -> ProductOrd a

setBit :: ProductOrd a -> Int -> ProductOrd a

clearBit :: ProductOrd a -> Int -> ProductOrd a

complementBit :: ProductOrd a -> Int -> ProductOrd a

testBit :: ProductOrd a -> Int -> Bool

bitSizeMaybe :: ProductOrd a -> Maybe Int

bitSize :: ProductOrd a -> Int

isSigned :: ProductOrd a -> Bool

shiftL :: ProductOrd a -> Int -> ProductOrd a

unsafeShiftL :: ProductOrd a -> Int -> ProductOrd a

shiftR :: ProductOrd a -> Int -> ProductOrd a

unsafeShiftR :: ProductOrd a -> Int -> ProductOrd a

rotateL :: ProductOrd a -> Int -> ProductOrd a

rotateR :: ProductOrd a -> Int -> ProductOrd a

popCount :: ProductOrd a -> Int

(Ord (ProductOrd a), FiniteBits a) => FiniteBits (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

Methods

finiteBitSize :: ProductOrd a -> Int

countLeadingZeros :: ProductOrd a -> Int

countTrailingZeros :: ProductOrd a -> Int

Generic1 ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

Associated Types

type Rep1 ProductOrd :: k -> Type

Methods

from1 :: forall (a :: k). ProductOrd a -> Rep1 ProductOrd a

to1 :: forall (a :: k). Rep1 ProductOrd a -> ProductOrd a

type Rep (ProductOrd a)

Defined in Numeric.ProductOrd.NonTransitive

type Rep (ProductOrd a) = D1 ('MetaData "ProductOrd" "Numeric.ProductOrd.NonTransitive" "easytensor-2.1.1.0-K3wnLX20lxZC5twIGEvVbn" 'True) (C1 ('MetaCons "ProductOrd" 'PrefixI 'True) (S1 ('MetaSel ('Just "getProductOrd") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

type Rep1 ProductOrd

Defined in Numeric.ProductOrd.NonTransitive

type Rep1 ProductOrd = D1 ('MetaData "ProductOrd" "Numeric.ProductOrd.NonTransitive" "easytensor-2.1.1.0-K3wnLX20lxZC5twIGEvVbn" 'True) (C1 ('MetaCons "ProductOrd" 'PrefixI 'True) (S1 ('MetaSel ('Just "getProductOrd") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

toOrdering :: PartialOrdering -> Ordering

Treat Incomparable as EQ (non-transitive equality).