arithmoi-0.12.1.0: Efficient basic number-theoretic functions.
Copyright(c) 2017 Andrew Lelechenko
LicenseMIT
MaintainerAndrew Lelechenko <andrew.lelechenko@gmail.com>
Safe HaskellSafe-Inferred
LanguageHaskell2010

Math.NumberTheory.Moduli.Class

Description

Safe modular arithmetic with modulo on type level.

Synopsis

Known modulo

data Mod (m :: Nat) #

Instances

Instances details
KnownNat m => Vector Vector (Mod m) 
Instance details

Defined in Data.Mod

KnownNat m => MVector MVector (Mod m) 
Instance details

Defined in Data.Mod

Methods

basicLength :: MVector s (Mod m) -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s (Mod m) -> MVector s (Mod m) Source #

basicOverlaps :: MVector s (Mod m) -> MVector s (Mod m) -> Bool Source #

basicUnsafeNew :: Int -> ST s (MVector s (Mod m)) Source #

basicInitialize :: MVector s (Mod m) -> ST s () Source #

basicUnsafeReplicate :: Int -> Mod m -> ST s (MVector s (Mod m)) Source #

basicUnsafeRead :: MVector s (Mod m) -> Int -> ST s (Mod m) Source #

basicUnsafeWrite :: MVector s (Mod m) -> Int -> Mod m -> ST s () Source #

basicClear :: MVector s (Mod m) -> ST s () Source #

basicSet :: MVector s (Mod m) -> Mod m -> ST s () Source #

basicUnsafeCopy :: MVector s (Mod m) -> MVector s (Mod m) -> ST s () Source #

basicUnsafeMove :: MVector s (Mod m) -> MVector s (Mod m) -> ST s () Source #

basicUnsafeGrow :: MVector s (Mod m) -> Int -> ST s (MVector s (Mod m)) Source #

KnownNat m => Storable (Mod m) 
Instance details

Defined in Data.Mod

Methods

sizeOf :: Mod m -> Int Source #

alignment :: Mod m -> Int Source #

peekElemOff :: Ptr (Mod m) -> Int -> IO (Mod m) Source #

pokeElemOff :: Ptr (Mod m) -> Int -> Mod m -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO (Mod m) Source #

pokeByteOff :: Ptr b -> Int -> Mod m -> IO () Source #

peek :: Ptr (Mod m) -> IO (Mod m) Source #

poke :: Ptr (Mod m) -> Mod m -> IO () Source #

KnownNat m => Bounded (Mod m) 
Instance details

Defined in Data.Mod

KnownNat m => Enum (Mod m) 
Instance details

Defined in Data.Mod

Methods

succ :: Mod m -> Mod m Source #

pred :: Mod m -> Mod m Source #

toEnum :: Int -> Mod m Source #

fromEnum :: Mod m -> Int Source #

enumFrom :: Mod m -> [Mod m] Source #

enumFromThen :: Mod m -> Mod m -> [Mod m] Source #

enumFromTo :: Mod m -> Mod m -> [Mod m] Source #

enumFromThenTo :: Mod m -> Mod m -> Mod m -> [Mod m] Source #

Generic (Mod m) 
Instance details

Defined in Data.Mod

Associated Types

type Rep (Mod m) :: Type -> Type Source #

Methods

from :: Mod m -> Rep (Mod m) x Source #

to :: Rep (Mod m) x -> Mod m Source #

KnownNat m => Num (Mod m) 
Instance details

Defined in Data.Mod

Methods

(+) :: Mod m -> Mod m -> Mod m Source #

(-) :: Mod m -> Mod m -> Mod m Source #

(*) :: Mod m -> Mod m -> Mod m Source #

negate :: Mod m -> Mod m Source #

abs :: Mod m -> Mod m Source #

signum :: Mod m -> Mod m Source #

fromInteger :: Integer -> Mod m Source #

KnownNat m => Read (Mod m) 
Instance details

Defined in Data.Mod

KnownNat m => Fractional (Mod m) 
Instance details

Defined in Data.Mod

Methods

(/) :: Mod m -> Mod m -> Mod m Source #

recip :: Mod m -> Mod m Source #

fromRational :: Rational -> Mod m Source #

KnownNat m => Real (Mod m) 
Instance details

Defined in Data.Mod

Methods

toRational :: Mod m -> Rational Source #

Show (Mod m) 
Instance details

Defined in Data.Mod

Methods

showsPrec :: Int -> Mod m -> ShowS Source #

show :: Mod m -> String Source #

showList :: [Mod m] -> ShowS Source #

NFData (Mod m) 
Instance details

Defined in Data.Mod

Methods

rnf :: Mod m -> () Source #

Eq (Mod m) 
Instance details

Defined in Data.Mod

Methods

(==) :: Mod m -> Mod m -> Bool Source #

(/=) :: Mod m -> Mod m -> Bool Source #

Ord (Mod m) 
Instance details

Defined in Data.Mod

Methods

compare :: Mod m -> Mod m -> Ordering Source #

(<) :: Mod m -> Mod m -> Bool Source #

(<=) :: Mod m -> Mod m -> Bool Source #

(>) :: Mod m -> Mod m -> Bool Source #

(>=) :: Mod m -> Mod m -> Bool Source #

max :: Mod m -> Mod m -> Mod m Source #

min :: Mod m -> Mod m -> Mod m Source #

KnownNat m => Prim (Mod m) 
Instance details

Defined in Data.Mod

KnownNat m => Euclidean (Mod m) 
Instance details

Defined in Data.Mod

Methods

quotRem :: Mod m -> Mod m -> (Mod m, Mod m)

quot :: Mod m -> Mod m -> Mod m

rem :: Mod m -> Mod m -> Mod m

degree :: Mod m -> Natural

KnownNat m => Field (Mod m) 
Instance details

Defined in Data.Mod

KnownNat m => GcdDomain (Mod m) 
Instance details

Defined in Data.Mod

Methods

divide :: Mod m -> Mod m -> Maybe (Mod m)

gcd :: Mod m -> Mod m -> Mod m

lcm :: Mod m -> Mod m -> Mod m

coprime :: Mod m -> Mod m -> Bool

KnownNat m => Ring (Mod m) 
Instance details

Defined in Data.Mod

Methods

negate :: Mod m -> Mod m

KnownNat m => Semiring (Mod m) 
Instance details

Defined in Data.Mod

Methods

plus :: Mod m -> Mod m -> Mod m

zero :: Mod m

times :: Mod m -> Mod m -> Mod m

one :: Mod m

fromNatural :: Natural -> Mod m

KnownNat m => Unbox (Mod m) 
Instance details

Defined in Data.Mod

newtype MVector s (Mod m) 
Instance details

Defined in Data.Mod

newtype MVector s (Mod m) = ModMVec (MVector s (Mod m))
type Rep (Mod m) 
Instance details

Defined in Data.Mod

type Rep (Mod m) = D1 ('MetaData "Mod" "Data.Mod" "mod-0.2.0.1-m2VyG6jF1fFpdOYap5kfD" 'True) (C1 ('MetaCons "Mod" 'PrefixI 'True) (S1 ('MetaSel ('Just "unMod") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Natural)))
newtype Vector (Mod m) 
Instance details

Defined in Data.Mod

newtype Vector (Mod m) = ModVec (Vector (Mod m))

getVal :: Mod m -> Integer Source #

The canonical representative of the residue class, always between 0 and m-1 inclusively.

getNatVal :: Mod m -> Natural Source #

The canonical representative of the residue class, always between 0 and m-1 inclusively.

getMod :: KnownNat m => Mod m -> Integer Source #

Linking type and value levels: extract modulo m as a value.

getNatMod :: KnownNat m => Mod m -> Natural Source #

Linking type and value levels: extract modulo m as a value.

invertMod :: forall (m :: Nat). KnownNat m => Mod m -> Maybe (Mod m) #

powMod :: (KnownNat m, Integral a) => Mod m -> a -> Mod m Source #

Synonym of (^%).

(^%) :: forall (m :: Nat) a. (KnownNat m, Integral a) => Mod m -> a -> Mod m #

Multiplicative group

data MultMod m Source #

This type represents elements of the multiplicative group mod m, i.e. those elements which are coprime to m. Use isMultElement to construct.

Instances

Instances details
KnownNat m => Monoid (MultMod m) Source # 
Instance details

Defined in Math.NumberTheory.Moduli.Multiplicative

KnownNat m => Semigroup (MultMod m) Source # 
Instance details

Defined in Math.NumberTheory.Moduli.Multiplicative

Methods

(<>) :: MultMod m -> MultMod m -> MultMod m Source #

sconcat :: NonEmpty (MultMod m) -> MultMod m Source #

stimes :: Integral b => b -> MultMod m -> MultMod m Source #

KnownNat m => Bounded (MultMod m) Source # 
Instance details

Defined in Math.NumberTheory.Moduli.Multiplicative

Show (MultMod m) Source # 
Instance details

Defined in Math.NumberTheory.Moduli.Multiplicative

Eq (MultMod m) Source # 
Instance details

Defined in Math.NumberTheory.Moduli.Multiplicative

Methods

(==) :: MultMod m -> MultMod m -> Bool Source #

(/=) :: MultMod m -> MultMod m -> Bool Source #

Ord (MultMod m) Source # 
Instance details

Defined in Math.NumberTheory.Moduli.Multiplicative

multElement :: MultMod m -> Mod m Source #

Unwrap a residue.

isMultElement :: KnownNat m => Mod m -> Maybe (MultMod m) Source #

Attempt to construct a multiplicative group element.

invertGroup :: KnownNat m => MultMod m -> MultMod m Source #

For elements of the multiplicative group, we can safely perform the inverse without needing to worry about failure.

Unknown modulo

data SomeMod where Source #

This type represents residues with unknown modulo and rational numbers. One can freely combine them in arithmetic expressions, but each operation will spend time on modulo's recalculation:

>>> 2 `modulo` 10 + 4 `modulo` 15
(1 `modulo` 5)
>>> (2 `modulo` 10) * (4 `modulo` 15)
(3 `modulo` 5)
>>> import Data.Ratio
>>> 2 `modulo` 10 + fromRational (3 % 7)
(1 `modulo` 10)
>>> 2 `modulo` 10 * fromRational (3 % 7)
(8 `modulo` 10)

If performance is crucial, it is recommended to extract Mod m for further processing by pattern matching. E. g.,

case modulo n m of
  SomeMod k -> process k -- Here k has type Mod m
  InfMod{}  -> error "impossible"

Constructors

SomeMod :: KnownNat m => Mod m -> SomeMod 
InfMod :: Rational -> SomeMod 

Instances

Instances details
Num SomeMod Source # 
Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

Fractional SomeMod Source #

Beware that division by residue, which is not coprime with the modulo, will result in runtime error. Consider using invertSomeMod instead.

Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

Show SomeMod Source # 
Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

Eq SomeMod Source # 
Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

Ord SomeMod Source # 
Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

Euclidean SomeMod Source #

See the warning about division above.

Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

Field SomeMod Source #

See the warning about division above.

Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

GcdDomain SomeMod Source #

See the warning about division above.

Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

Ring SomeMod Source # 
Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

Methods

negate :: SomeMod -> SomeMod

Semiring SomeMod Source # 
Instance details

Defined in Math.NumberTheory.Moduli.SomeMod

modulo :: Integer -> Natural -> SomeMod infixl 7 Source #

Create modular value by representative of residue class and modulo. One can use the result either directly (via functions from Num and Fractional), or deconstruct it by pattern matching. Note that modulo never returns InfMod.

invertSomeMod :: SomeMod -> Maybe SomeMod Source #

Computes the inverse value, if it exists.

>>> invertSomeMod (3 `modulo` 10) -- because 3 * 7 = 1 :: Mod 10
Just (7 `modulo` 10)
>>> invertSomeMod (4 `modulo` 10)
Nothing
>>> import Data.Ratio
>>> invertSomeMod (fromRational (2 % 5))
Just 5 % 2

powSomeMod :: Integral a => SomeMod -> a -> SomeMod Source #

Drop-in replacement for ^, with much better performance. When -O is enabled, there is a rewrite rule, which specialises ^ to powSomeMod.

>>> powSomeMod (3 `modulo` 10) 4
(1 `modulo` 10)

Re-exported from GHC.TypeNats.Compat

class KnownNat (n :: Nat) Source #

This class gives the integer associated with a type-level natural. There are instances of the class for every concrete literal: 0, 1, 2, etc.

Since: base-4.7.0.0

Minimal complete definition

natSing