Was ist der konkrete Unterschied von rem und modulo in der funktionalen Programmierung?

Hi,

was ist der Unterschied zwischen mod und rem in Haskell?

Bei der Eingabe ins GHCI erhält man das gleiche Resultat.

(-4 `mod` 5) == (-4 `rem` 5)

TRUE

Allerdings ist hier FALSE:

(4 `mod` (-5)) == (4 `rem` (-5))

Habe im Internet recherchiert und das hier gefunden.

https://stackoverflow.com/questions/5891140/difference-between-mod-and-rem-in-haskell

"Yes, those functions act differently. As defined in the official documentation:

quot

is integer division truncated toward zero

rem

is integer remainder, satisfying:

(x `quot` y)*y + (x `rem` y) == x

div

is integer division truncated toward negative infinity

mod

is integer modulus, satisfying:

(x `div` y)*y + (x `mod` y) == x

Kann mir einer erklären, was diese Zeilen bedeuten? (integer modulus, integer remainder?

1 Antwort

Vom Fragesteller als hilfreich ausgezeichnet

MagicalGrill

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Mathematik

13.12.2020, 15:16

Die Frage ist einfach, wie du bei der Ganzzahldivision rundest.

Hintergrund: Wenn du zwei natürliche Zahlen a und b hast, kannst du die "Division mit Rest" aus der Grundschule durchführen, also a / b = q, Rest r. Oder anders ausgedrückt:

a = b * q + r mit r < b.

Jetzt haben wir das Problem, dass a und b nicht unbedingt natürliche Zahlen sein müssen, sondern beliebige ganze Zahlen sein können. Und mit ganzzahligen Nennern und Resten ist diese Division mit Rest nicht mehr eindeutig. Zum Beispiel:

4 = 0 * (-5) + 4

oder auch:

4 = (-1) * (-5) + (-1).

In beiden Fällen ist |r| < |b|, weswegen beides valide Antworten wären.

Die Frage ist also, was wir als Quotienten betrachten wollen:

Ist 4/(-5) = 0 oder 4/(-5) = (-1)?

Die erste Antwort wäre das Runden zur 0 hin, die zweite Antwort wäre "immer abrunden". Und genau das ist auch der Unterschied:

4 `quot` (-5) = 0, während

4 `div` (-5) = -1.

Dementsprechend ist

4 `rem` (-5) = 4 und

4 `mod` (-5) = -1.

... Wenn du das alles bis hierhin verstanden hast, fragst du dich sicher, weshalb deine erste Eingabe "TRUE" zurückliefert. Das tut sie, weil das Minus-Symbol schwächer bindet als `rem` und `mod`. Du hättest stattdessen

((-4) `mod` 5) == ((-4) `rem` 5)

eingeben sollen.

Mueller345

Fragesteller

14.12.2020, 14:09

Vielen Dank.
Also, bei mir haperts schon am Anfang.

4 = 0 * (-5) + 4
4 = 4 (wahr) 4 < 0 ist falsch

4 = (-1) * (-5) + (-1).
4 = 4 (wahr) -1 < -1 ist falsch

Die zwei Senkricht-Striche bedeuten Betrag, oder?

Wäre nett, wenn du mir den Teil hier nochmal kurz erklären würdest, bevor ich dann den restlichen Teil versuche, zu begreifen.

MagicalGrill

14.12.2020, 14:31

@Mueller345

Ja, die senkrechten Striche sind Betragszeichen.

Zugegebenermaßen hab ich die Faktoren heimlich vertauscht. Wenn wir bei der Form

a = bq + r

bleiben wollen, hätte ich eher

4 = (-5) * 0 + 4 schreiben sollen. Dann wäre nämlich

|4| < |-5| korrekt. Analog wäre

4 = (-5) * (-1) + (-1) mit

|-1| < |-5|.

Ähnliche Fragen

Ganzzahlige Division

Kann mir einer erklären was eine ganzzahlige Division ist? Also zum Beispiel wie man, 13 div 3 oder 13 mod 3 ausrechnen kann.

Danke!

...zur Frage

Division in Assembly. Zeichen sind in ASCII gespeichert?

section .text
global main

main:
  mov esi, 10           ; ESI holds current number
  mov eax, 0           ; EAX holds sum of numbers
  push 10             ; Line feed for end of line (Stack is first in, last out -> Line feed will be last char)
  mov edi, 10           ; Divisor of 10 for seperating digits of number (used in divisionLoop)



; Sum numbers 1 through 10
sumLoop:
  add eax, esi          ; Add number to sum
  dec esi             ; Next number
  jnz sumLoop           ; Loop until 0



; Seperate eax into its digits, by dividing by 10 multiple times,
; where in each division the remainder will be a single digit 
; and the quotient will be the remaining digits used as dividend in next loop run
divisionLoop:
  mov edx, 0           ; Make sure edx is empty, as it is used as upper half of dividend
  div edi             ; Divide eax by edi (= 10) => quotient is in eax (= Rest of digits for next loop), remainder in edx (= Single digit)
  add edx, 48           ; Make edx (digit) a char representing its value by adding '0' to it
  push edx            ; Push char to stack for usage in print later

  cmp eax, 0           ; Loop until quotient is 0 (=> no more digits left)
  jne divisionLoop



; Print digits from Stack one by one
printLoop:
  mov eax, 4
  mov ebx, 1
  mov ecx, esp          ; Print top of stack (esp always points to top of stack)
  mov edx, 1           ; Length of 1 byte (= 1 char)
  int 80h

  pop esi             ; Remove top of stack
  cmp esi, 10           ; Loop until Line feed is reached
  jne printLoop


exit:
  mov eax, 1
  mov ebx, 0           ; Exit code 0
  int 80h

Hallo,

hier steht ein Programm in Assembler, dass die Zahlen von 1 bis 10 addiert.

Die 55 durch 10 teilt und die Reste der Division dann in einem Stack speichert.

push....

Am Ende wird alles über den Standardkanal ausgegeben auf der Konsole.

Wenn ich 55 / 10 teile ergibt das Quotient 5 steht in Register eax und der Rest hier auch 5 in edx Register. Bevor ich jetzt den Rest auf den Stack lege wird die Zahl mit 48 addiert. ergbit 53 ist das char Zeichen 5 im ASCII Code.

Heißt das jetzt, dass die Ergebnisse bei einer ganzzahligen Division im Assembler-Code immer in ASCII-Zeichen gespeichert sind?

...zur Frage

Struktuelle Induktion auf Bäumen?

Aufgabe:

Betrachten wir die folgenden Funktionsdefinitionen :

data Tree a = Leaf a | Node a (Tree a) (Tree a)

sumLeaves :: Tree a -> Integer

sumLeaves (Leaf x) = 1

sumLeaves (Node _ lt rt) = sumLeaves lt + sumLeaves rt

sumNodes :: Tree a -> Integer

sumNodes (Leaf x) = 0

sumNodes (Node _ lt rt) = 1 + sumNodes lt + sumNodes rt

Beweisen Sie mittels struktureller Induktion, dass für alle endlichen Bäume t :: Tree a gilt:

sumLeaves t = sumNodes t + 1

...zur Frage

Beweis durch strukturelle Induktion?

Wir haben folgende Funktionen:

prod :: [Int] -> Int

prod [] = 1 -- prod.1

prod (x:xs) = x * prod xs -- prod.2

foldl :: (b -> a -> b) -> b -> [a] -> b

foldl f acc [] = acc -- foldl.1

foldl f acc (x:xs) = foldl f (f acc x) xs -- foldl.2

Aufgabe:

Man soll mit struktureller Induktion beweisen, dass folgende Aussage gilt:

foldl (*) 1 xs = prod xs

Ich habe momentan:

foldl (*) 1 xs = prod xs

I.A. (xs = []):

foldl (*) 1 [] = prod []

foldl f acc [] = acc prod [] = 1 -- foldl.1 & plod.1

foldl f 1 [] = 1

1 = 1

I.V.: Wir nehmen an, dass die Aussage gilt für ein beliebiges xs

I.S. (xs -> x:xs):

foldl (*) 1 (x:xs) = prod (x:xs) -- foldl.2 & prod.2

foldl (*) ((*) 1 x) xs = x * prod xs

Problem: Ich weiß nun nicht wie ich mit dem Induktionsschritt fortfahren soll.

...zur Frage

Wie kann ich diese Aufgabe mit Haskell lösen?

Ich brauche Hilfe bei folgender Aufgabe.

Schreiben Sie eine Funktion, die überprüft ob ein eingegebenes Zeichen eine Ziffer ist.

(a) Durch direktes Angeben eines Booleschen Ausdrucks

(b) Verwenden Sie Pattern-Matching

...zur Frage

Haskell-File auf Mac öffnen?

Guten Abend,

unszwar geht es darum, daß wir versucht haben auf Mac eine Haskell-Datei namens hallowelt.hs zu öffnen. Die Datei haben wir mit einem Texteditor geschrieben und möchten sie nun ihm Compiler GHCi 8.6.3 öffnen. Auf Windows klappt alles tadellos. Man klickt mit Rechtsklick auf "Öffnen mit GHCi 8.6.3." und die Datei öffnet sich im Compiler.

Auf Mac klappt es leider nicht. Da steht dann "Öffnen mit anderen Programm" und wenn wir dann den Rechner durchsuchen finden wir GHCi 8.6.3 nicht, obwohl GHCi auf dem Mac installiert ist und nachweislich funktioniert.

Haben auch probiert direkt über GHCi das Modul zu laden, aber es zeigt immer eine Fehlermeldung an, daß diese Datei nicht gefunden wurde, obwohl sie unter Downloads gespeichert wurde. Woran könnte das liegen?

PS: Wer sich wundert. In dem geschwärzten steht nur der Klarname der Person, welcher der Mac gehört. Bin mir nicht sicher, ob sie das so cool finden würde, daß der hier im Internet auftaucht, deswegen geschwärzt.

Wo liegt der Fehler?

Danke und liebe Grüße

...zur Frage

Die Funktion soll sich nach Beendigung der Rekursion wiederholen?

Ich versuche, Bubblesort in Haskell zu implementieren:

bsort:: (Ord a) => [a] -> [a]
bsort [] = []
bsort [x] = [x]
bsort (x:y:xs)
    | x <= y = x: bsort(y:xs)
    | x >= y = y: bsort(x:xs)

Nachdem die Funktion ausgeführt wurde, wird der gesamte Vorgang nicht noch einmal wiederholt, so dass die Liste nicht vollständig sortiert ist. Wie kann ich der Funktion sagen, dass sie sich wiederholen soll, bis die Liste vollständig sortiert ist?

Wenn ich zum Beispiel eintippe: bsort [1,5,2,4] erhalte ich [1,2,4,5]

aber wenn ich eintippe: bsort [9,6,1,5,2,4] erhalte ich [6,1,5,2,4,9], wie sage ich, dass der Prozess mit [6,1,5,2,4,9] wiederholt werden soll?

...zur Frage

Informatik Rekursion und Iteration unterschied?

Servus, wir machen in Info gerade Haskell und da werden die Konzepte der Rekursion und Iteration besprochen.

Ich versteh den Unterschied einfach noch nicht. Könnte mir das einer einfach zusammenfassen?

Rekursion und Iteration rufen sich doch beide selber im Funktionsrumpf auf und dekrementieren bis beim conditional statement ein False erscheint. Ich kann den Unterschied einfach nicht sehen.

Danke schonmal für die Antworten :D

...zur Frage

Haskell Funktion Frage?

Wenn man eine Funktion erstellen soll, bei der die Funktion zwei Werte nimmt und prüft, ob ein Wert durch den anderen teilbar ist, wie schreibt man das in Haskell als Code?

nehmen wir an:

isDivisible -> Integer -> Integer -> Bool

Wie schaut dann der Rest aus? So?

isDivisible x % y == 0 = true else false

y % x == 0 = true else false?? Das klingt so bescheuert aber ich weiß sonst nicht wie es aussehen sollte! Kann mir da wer weiterhelfen?

Zusätzlich müsste ich dann auch eine Funktion schreiben, die so aussieht:

isPrime -> Integer -> Bool

welches eine Zahl nimmt und ausgibt ob diese eine Primzahl ist oder nicht, dafür soll ich die vorherige Funktion benutzen, jedoch komm ich da eben nicht weiter. Und bei der hier bin ich mir auch nicht sicher, wie würde da der Code aussehen?

...zur Frage

Beste Pogrammiersprache?

Hi, ich bin Pogrammierer und kann sehr viele Sprachen: C#, Node js, python, Javascript usw. Nur möchte ich gerne wissen, wie beliebt die beliebige Sprache ist.

...zur Frage

Benutzen richtige gute Programmierer wirklich so oft Stackoverflow?

Man sieht immer übertrieben viele Memes etc. das Programmierer besonders viel mit Stackoverflow etc. arbeiten und der meiste Code zusammengegoolt wird. Ich arbeite auch mit einigen Programmiersprachen auf Freizeitbasis und mich fuckt das unglaublich ab, alle 2 Minuten irgendwas zu googeln weil etwas nicht funktioniert oder ich nicht weiß wie es geht, weil es auch viel Zeit frisst die richtige Lösung zu finden. Deswegen frage ich mich ob die wirklich professionellen Programmierer echt so viel solche Sachen benutzen oder ob das mehr bei den Amateurprogrammieren so der Fall ist?

...zur Frage

Haskell programmieren auf Notepad++?

will bisschen mit haskell rumarbeiten und wenn ich ein stück code starten will kommt nur ein fenster auf wo drauf steht "ausführen - Ausführende Programme hier eingeben". mache das zum ersten mal mit notepad sorry

...zur Frage

Welches Programm nutzt mein Professor zum Ausführen von Programmen mit den Programmiersprachen Prolog und Haskell?

...zur Frage

Haskell Vektoren addieren?

Hey, die Aufgaben lauten:

1. Eine Funktion schreiben die Vektoren addiert

2. Eine Funktion die Skalarprodukt berechnet und

3. Eine Funktion die anhand des Skalarprodukts bestimmen kann, ob der Winkel rechtwinklig ist.

Meine Ansätze:

addVectors:: (Num a) => a -> a -> a

addVectors (a1, a2, a3) (b1, b2, b3) = (a1 + b1) (a2 + b2) (a3 + b3)

scalarProduct:: (Num a) => a -> a -> a