wiskunde: div en mod

[Krooswijk.com]

omdat ik zelf niks goeds heb kunnen vinden en me dit het beste forum leek, deze vraag:

in haskell ben ik een paar functies aan het maken die met div en mod werken. geen probleem. maar
ik wilde weten of iemand een overzichtje heeft op internet met alle div en mod 'trucs' of regels.

zoals bv
(n+1) mod 2 = ( ( n mod 2 ) + ( 1 mod 2 ) ) mod 2

weet iemand een overzichtje met zulk soort regels? bvd.

[RobIII]

Geen idee wat je bedoelt. Waar is het voor? Je weet wel wat div en mod doen?

[Krooswijk.com]

uiteraard, maar om te bewijzen dat mijn programma klopt, heb ik dus ook enkele omschrijfregels ('trucjes') voor die div en mod nodig. of iemand daar een soort van overzichtje van heeft.

[MTWZZ]

Ik zou even rondneuzen op wisfaq daar moet wel wat te vinden zijn denk ik.

[Woy]

Die "truc" die jij noemt is volgens mij de regel dat als je iets modulo uitrekent je ook alle substappen modulo mag doen en dan dezelfde uitkomst krijgt.

en ( 1 Mod 2 ) is niet echt nuttig he

[CaptBiele]

kun je dat soort dingen niet uit de documentatie van een ander rekenprogramma halen, zoals Derive?

[Zoijar]

Zoiets?

code:

-- Modulo operator for Num
modulo::Num a => a -> a -> a
modulo x y = x - (x / y) * y

-- Performs the extended euclidian algorithm
-- Returns a triplet (gcd(a, b), x, y) where x*a + y*b = gcd(a,b)
extEuclid::Num a => (a, a) -> (a, a, a)
extEuclid (a, b) = 
 extEuclid' (a, fromInteger 1, fromInteger 0) (b, fromInteger 0, fromInteger 1)
  where
   extEuclid' (a1, x1, y1) (a2, x2, y2)
       -- Stop and return result if a2 divides a1
     | a1 `modulo` a2 == fromInteger 0 = (a2, x2, y2)
       -- Generate the next triplet n+1 from n and n-1 and recurse
     | otherwise = extEuclid' (a2, x2, y2) (a1 - q * a2, x1 - q * x2, y1 - q * y2)
                    where q = a1 / a2

-- The modulo data type
data ModInt = Mod Int

-- Two ModInts are equal iff p divides their difference
instance Eq ModInt where
   Mod a == Mod b = (b - a) `mod` p == 0

-- Standard modulo arithmetic
instance Num ModInt where
   Mod a + Mod b = Mod ((a + b) `mod` p)
   Mod a - Mod b = Mod ((a - b) `mod` p)
   Mod a * Mod b = Mod ((a * b) `mod` p)
   Mod a / Mod b = Mod ((a * snd3 (extEuclid (b, p))) `mod` p)
   negate (Mod a) = Mod ((negate a) `mod` p)
   fromInteger i = Mod (i `mod` p)

? (functionele, gofer, definitie van een mod class)

[ Voor 43% gewijzigd door Zoijar op 26-04-2005 11:24 ]

[Krooswijk.com]

heb inderdaad in de functiebeschrijvingen van hugs zitten kijken, maar daar zit niks nieuws tussen.
sites als wikipedia en wisfaq gaan ook niet diep

rwb schreef op dinsdag 26 april 2005 @ 10:43:
...

en ( 1 Mod 2 ) is niet echt nuttig he

denk dat deze toch echt nodig is als tussenstap voor inductieve bewijs

ik ga naar de bieb toe voor wat boekwerk, iig bedankt

[ Voor 7% gewijzigd door Krooswijk.com op 26-04-2005 11:39 ]

[NMe]

Zie http://en.wikipedia.org/wiki/Modulo of http://en.wikipedia.org/wiki/Division. Anyway, ik zie hier geen concreet programmeerprobleem in, dus dit topic gaat op slot. Wanneer je wat meer vooronderzoek gedaan zou hebben, dan had ik je topic kunnen verplaatsen naar Wetenschap & Levensbeschouwing, maar omdat dat mist kies ik toch maar voor een slotje.

Lees de bovenstaande links maar even door.