Comments on: Modular Arithmetic

By: Lii

Lii — Sat, 03 Dec 2011 17:25:59 +0000

Here is a variant of the above code where the operation take and return functions. The intention is to get rid of the ugliness of having to pass the modulo value in every function invocation.

The disadvantage is that you cant use ints directly in the expressions, you have to wrap them in the ugly i functions. Is there a solution to this?

test_func = ((i 5) *% (i 6) +% (i 7)) 13


(=%) :: TModNum -> TModNum -> (Integer -> Bool)

a =% b = \m -> (a m) == (b m)
type TModNum = (Integer -> Integer)
(+%), (-%), (*%), (/%) :: TModNum -> TModNum -> TModNum
a +% b = \m -> mod ((a m) + (b m)) m

a -% b = \m -> mod ((a m) - (b m)) m

a *% b = \m -> mod ((a m) * (b m)) m

a /% b = \m -> mod ((a m) * (inv (b m) m)) m

i :: Integer -> (Integer -> Integer) i n = \m -> mod n m

By: programmingpraxis

programmingpraxis — Mon, 12 Oct 2009 19:08:32 +0000

Here is an improved version of modular inverse, based on Algorithm 9.4.4 from the book Prime Numbers: A Computational Perspective by Richard Crandall and Carl Pomerance:

(define (inverse x m) (if (not (= (gcd x m) 1)) (error 'inverse "divisor must be coprime to modulus") (let loop ((z (modulo x m)) (a 1)) (if (= z 1) a (let ((q (- (quotient m z)))) (loop (+ m (* q z)) (modulo (* q a) m)))))))

By: Posts about Programming from google blogs as of July 8, 2009 « tryfly.com

Posts about Programming from google blogs as of July 8, 2009 « tryfly.com — Wed, 08 Jul 2009 23:46:48 +0000

[...] OLE 2 or ActiveX, we are referring to a very specific type of object, sometimes called a … Modular Arithmetic « Programming Praxis – programmingpraxis.com 12/31/1969 Programming Praxis. A collection of etudes, updated weekly, for [...]

By: Remco Niemeijer

Remco Niemeijer — Wed, 08 Jul 2009 09:27:57 +0000

My Haskell solution (see http://bonsaicode.wordpress.com/2009/07/08/programming-praxis-modular-arithmetic/ for a version with comments):

import Data.Bits
import Data.List

euclid :: Integral a => a -> a -> a
euclid x y = f 1 0 x 0 1 y where
    f a b g u v w | w == 0    = mod a y
                  | otherwise = f u v w (a-q*u) (b-q*v) (g-q*w)
                                where q = div g w

inv :: Integral a => a -> a -> a
inv x m | gcd x m == 1 = euclid x m
        | otherwise    = error "divisor must be coprime to modulus"

(<=>) :: Integral a => a -> a -> a -> Bool
a <=> b = \m -> mod a m == mod b m

(<+>), (<->), (<*>), () :: Integral a => a -> a -> a -> a
a <+> b = \m -> mod (a + mod b m) m
a <-> b = a <+> (-b)
a <*> b = \m -> mod (a * mod b m) m
a  b = \m -> (a <*> inv b m) m

expm :: Integer -> Integer -> Integer -> Integer  
expm b e m = foldl' (\r (b', _) -> mod (r * b') m) 1 .  
             filter (flip testBit 0 . snd) .  
             zip (iterate (flip mod m . (^ 2)) b) $
             takeWhile (> 0) $ iterate (`shiftR` 1) e

(<^>) :: Integer -> Integer -> Integer -> Integer
(<^>) = expm

sqrtm :: Integral a => a -> a -> [a]
sqrtm x m = case [n | n <- [1..m], (n <*> n) m == mod x m] of
                (_:_:_:_) -> []
                s         -> s

modulo :: a -> (a -> b) -> b
modulo = flip ($)

main :: IO ()
main = do mapM_ (modulo 12) [
              print . (17 <=> 5),
              print . (8 <+> 9),
              print . (4 <-> 9),
              print . (3 <*> 7),
              print . (9  7)]
          mapM_ (modulo 13) [ 
              print . (6 <^> 2),
              print . (7 <^> 2),
              print . sqrtm 10]

By: Programming Praxis – Modular Arithmetic « Bonsai Code

Programming Praxis – Modular Arithmetic « Bonsai Code — Wed, 08 Jul 2009 09:27:19 +0000

[...] Praxis – Modular Arithmetic By Remco Niemeijer Yesterday’s Programming Praxis problem is about making a convenient way to do modular arithmetic. While the [...]