Scala Operatoren selber schreiben

[theoretisch]

Hallo und guten Abend,

ich "möchte" die Operatoren für die arithmetischen Grundrechenarten (+/-/:/*) selber schreiben.
Nur leider weiß ich absolut nicht wie ich da anfangen soll.
Ich darf keine Funktionen aus der scala api benutzen und natürlich auch nicht +,- etc. selbst und auch keine Variablen.
Meine Ideen waren das ich das vielleicht machen kann indem ich mit Binärzahlen rechne.
Nur leider darf ich die Funktion die die zahlen in Binärzahlen umwandelt nicht nutzen.
Mein zweiter Ansatz war das irgendwie mit Rekursion zu lösen.. wo ich letzten Endes dann aber auch wieder an dem Punkt war wo ich dann irgendwas addieren oder subtrahieren musste was ja nicht erlaubt ist.
Wie fange ich da an ?... habe bis jetzt kaum mit Scala programmiert... bin also ein Neuling.
Kann mir vielleicht jemand einen Ansatz geben, oder hat eine Idee wie ich das machen kann?

Vielen Dank
theoretisch

 

[Flown]

Welche Operationen darfst du dann verwenden? Bzw. poste doch mal die Aufgabenstellung.

 

[theoretisch]

Vielen Dank für die schnelle Antwort.
Die Aufgabe heißt:
Schreibe die Klasse Rat mit Funktionen für die arithmetischen Grundrechenarten +, −, *, /, sowie einer Vergleichsfunktion equals.
Erstelle alle Funktionen und Hilfsfunktionen wie ggT rein funktional und ohne Funktionen aus der scala api.
Aber wenn ich + irgendwie hinkriege dann hoffe ich das ich die anderen Operatoren davon ableiten kann...

 

[tommysenf]

class Rat(numer: Int = 1, denom: Int = 1) {
   def +(that: Rational) =
        new Rational(that.numer * denom + numer * that.denom, denom * that.denom)
}

 

[theoretisch]

hmm, danke @tommysenf.
so ganz geht dein Code bei mir nicht.. und ich weiß nicht ob ich ihn richtig verstehe.
Ich kriege den Fehler das er den Type Rational nicht findet... hast du dich da vielleicht vertippt und meintest stattdessen die Klasse Rat?

class Rat(numer: Int = 1, denom: Int = 1) {
   def +(that: Rat) =
        new Rat(that.numer * denom + numer * that.denom, denom * that.denom)
}

Wenn ich so wie oben Rational durch Rat ersetze dann habe ich nur noch den Fehler das numer und denom "not a member of Aufgabe5A3.Rat" sind.

Und mal zum Verständnis. Du hast eine Methode "+" gemacht der du die Klasse Rat als Parameter übergibst. Dann machst du eine neue Instanz von Rat und übergibst der dann that.numer * denom + numer * that.denom als numer und denom * that.denom als denom, habe ich das richtig verstanden ?
Aber jetzt verwendest du ja schon die Operatoren * und + in der Methode... was ich nicht machen darf.
Oder rufst du die Methode "+" rekursiv auf und ich verstehe das falsch?

 

[tommysenf]

Sorry, das ganze war nur ein verkürztes Beispiel und ich habe vergessen Rational überall in Rat umzubenennen wie es in deiner Aufgabenstellung stand.

Du brauchst natürlich noch Membervariablen in der Klasse Rat. (Ich war irrtümlicherweise der Meinung Scala erstellt diese implizit)

Also:

class Rat(n: Int =1, d: Int =1){

  
   val number = n
   val denom = d

   def +(that: Rat)=
       new Rat(that.numer* denom + numer * that.denom, denom * that.denom)
}

Dass du nicht +,- etc. Verwenden darfst halte ich für eine Missinterpretation der Aufgabenstellung von Dir. Ich Glaube nicht das der Aufgabensteller diese mit unter die API Funktionen gerechnet hat, und würde daher noch einmal nachfragen.

 

[theoretisch]

asoo ok danke, da hätte ich auch selber drauf kommen können , sorry.

jaa das das nicht mit unter die api funktionen gehört das glaube ich auch.
Aber ich dachte mir wenn ich die Operatoren schreibe und dann dort schon die Operatoren verwende dann muss ich ja nicht erst die Operatoren schreiben.. oder ?

 

[tommysenf]

Ich glaube, du hast da noch ein Verständnisproblem. Du implementiert die Operation + für die Klasse Rat und nutzt in der Implementierung die Operation + der Klasse Int. Beides sind 2 völlig verschiedene Operationen.

Hier mal als Pseudo Code ohne Operatorenüberladung:

def Rat.plus( that: Rat) =
       new Rat( Int.plus( Int.mul(that.numer, denom), Int.mul(numer, that.denom)), Int.mul(denom, that.denom))

 

[theoretisch]

oh man.. das is gar nicht so einfach, sorry für den ganzen Aufwand..
ich hab mich mal ein bisschen mit Operatorenüberladung beschäftigt.. aber wirklich durchblicken tu ich da nicht...

Danke für dein Beispiel ohne Überladung... da rufen wir die Funktion plus also mit Int.plus rekursiv auf oder ? und woher kommt das mul von Int.mul is das noch eine andere Funktion die ich schreiben muss?

 

[tommysenf]

Nein hier wird gar nichts rekursiv aufgerufen. Rat.plus() und Int.plus() sind nicht die gleiche Funktion, also findet auch keine Rekursion statt.
Int.plus() ist die normale Addition von Integer also das + und das ist in Scala ja schon implementiert.
Int.plus(1,1) == 1+1 == 1.plus(1)
Das ganze soll nur der Veranschaulichung dienen kund ist kein gültiger Scala Code.
Was findest du denn an Operatorenüberladung so kompliziert? Im Prinzip ist es doch wie die Implementierung jeder anderen Funktion, nur das die Aufrufsyntax anders aussieht.

 

[theoretisch]

achso, du benutz also einfach das + und * aus scala um dein eigenes + zu schreiben ?
Irgendwie komme ich mit der Schreibweise von scala generell nicht wirklich zurecht (auch wenn der prof mein die sei sehr einfach zu lesen und man würde sofort sehen welche funktion der code hat)... ich habe bis jetzt nur mit java gearbeitet.