Polynome Übungsaufgabe uni

  • Themenstarter Themenstarter Heyoka955
  • Beginndatum Beginndatum
H

Heyoka955

Gast
Hallo Leute, ich habe ein Problem mit einer Uni aufgabe und zwar sollen wir eine Klasse schreiben wo wir ein Obhekt vom Typ Polynom programmieren sollen und ich habe schon die Instanzen festgelegt und doe Kontruktoren belegt jedoch scheitere ich bei der toAdd Methode und die restlichen. Ich werde die Aufgabe euch senden und die Aufgabenstellung un ddie junit Tests. Also die Polynomaufgabe. Ich würde gerne die junit Tests hochladen und mein Code aber weiß ich nicht wie das machen soll.
 

Anhänge

Das sind die Tests
Java: 
import static org.junit.Assert.*;
import org.junit.Test;
public class PolynomTest {
    Polynom p1 = new Polynom(2, 0, 1, 3);
    Polynom p2 = new Polynom(1, 2, 6, 5);
    Polynom p3 = new Polynom(3, 3, 0, 3);
    Polynom p4 = new Polynom(6, 4, 10, 5);
    Polynom p5 = new Polynom(8, 9, 6, 0);
    Polynom p6 = new Polynom(0, 2, 5, 8);
    Polynom p7 = new Polynom(6, 5, 4, 9);
    Polynom p8 = new Polynom(5, 7, 0, 1);
    [USER=5814]@test[/USER]
    public void constructor1() {
        Polynom p = new Polynom(5);
        assertEquals(5, p.map(10), "constructor");
    }
    [USER=5814]@test[/USER]
    public void constructor2() {
        Polynom p = new Polynom(1, 2);
        assertEquals(12, p.map(10), "constructor");
    }
    [USER=5814]@test[/USER]
    public void constructor3() {
        Polynom p = new Polynom(1, 2, 3);
        assertEquals(123, p.map(10), "constructor");
    }
    [USER=5814]@test[/USER]
    public void constructor4() {
        Polynom p = new Polynom(1, 2, 3, 4);
        assertEquals(1234, p.map(10), "constructor");
    }
    [USER=5814]@test[/USER]
    public void test1() {
        assertEquals("2*x^3 + x + 3", p1.toString(), "toString");
        assertEquals(21, p1.map(2), "map");
        assertEquals("6*x^2 + 1", Polynom.derivation(p1).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test2() {
        assertEquals("x^3 + 2*x^2 + 6*x + 5", p2.toString(), "toString");
        assertEquals(329, p2.map(6), "map");
        assertEquals("3*x^2 + 4*x + 6", Polynom.derivation(p2).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test3() {
        assertEquals("3*x^3 + 3*x^2 + 3", p3.toString(), "toString");
        assertEquals(2433, p3.map(9), "map");
        assertEquals("9*x^2 + 6*x", Polynom.derivation(p3).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test4() {
        assertEquals("6*x^3 + 4*x^2 + 10*x + 5", p4.toString(), "toString");
        assertEquals(25, p4.map(1), "map");
        assertEquals("18*x^2 + 8*x + 10", Polynom.derivation(p4).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test5() {
        assertEquals("8*x^3 + 9*x^2 + 6*x", p5.toString(), "toString");
        assertEquals(0, p5.map(0), "map");
        assertEquals("24*x^2 + 18*x + 6", Polynom.derivation(p5).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test6() {
        assertEquals("2*x^2 + 5*x + 8", p6.toString(), "toString");
        assertEquals(26, p6.map(2), "map");
        assertEquals("4*x + 5", Polynom.derivation(p6).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test7() {
        assertEquals("6*x^3 + 5*x^2 + 4*x + 9", p7.toString(), "toString");
        assertEquals(24, p7.map(1), "map");
        assertEquals("18*x^2 + 10*x + 4", Polynom.derivation(p7).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test8() {
        assertEquals("5*x^3 + 7*x^2 + 1", p8.toString(), "toString");
        assertEquals(433, p8.map(4), "map");
        assertEquals("15*x^2 + 14*x", Polynom.derivation(p8).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void add1() {
        p6.add(p5);
        assertEquals("8*x^3 + 11*x^2 + 11*x + 8", p6.toString(), "add");
    }
    [USER=5814]@test[/USER]
    public void add2() {
        p2.add(p7);
        assertEquals("7*x^3 + 7*x^2 + 10*x + 14", p2.toString(), "add");
    }
    [USER=5814]@test[/USER]
    public void add3() {
        p3.add(p4);
        assertEquals("9*x^3 + 7*x^2 + 10*x + 8", p3.toString(), "add");
    }
    [USER=5814]@test[/USER]
    public void add4() {
        p5.add(p1);
        assertEquals("10*x^3 + 9*x^2 + 7*x + 3", p5.toString(), "add");
    }
    [USER=5814]@test[/USER]
    public void sub1() {
        p7.subtract(p2);
        assertEquals("5*x^3 + 3*x^2 - 2*x + 4", p7.toString(), "subtract");
    }
    [USER=5814]@test[/USER]
    public void sub2() {
        p3.subtract(p5);
        assertEquals("-5*x^3 - 6*x^2 - 6*x + 3", p3.toString(), "subtract");
    }
    [USER=5814]@test[/USER]
    public void sub3() {
        p1.subtract(p6);
        assertEquals("2*x^3 - 2*x^2 - 4*x - 5", p1.toString(), "subtract");
    }
    [USER=5814]@test[/USER]
    public void sub4() {
        p4.subtract(p8);
        assertEquals("x^3 - 3*x^2 + 10*x + 4", p4.toString(), "subtract");
    }
 
    public static void assertEquals(int expected, int actual, String method) {
        System.out.print("Testing " + method + " ");
        if (expected != actual) {
            System.out.println("failed. Expected " + expected + " but got " + actual + ".");
            } else {
                System.out.println("succeeded.");
        }
    }
   
    public static void assertEquals(String expected, String actual, String method) {
        System.out.print("Testing " + method + " ");
        if (expected == null || !expected.equals(actual)) {
            System.out.println("failed.");
            System.out.println("## Expected:");
            System.out.println(expected);
            System.out.println("## Actual:");
            System.out.println(actual);
            if (expected.length() != actual.length()) {
             System.out.println("Length of the Strings differ. Expected "+ expected.length() + " but got " + actual.length());
            } else {
                System.out.println("Length are ok.");
                for (int i = 0; i < expected.length(); i++) {
                    if (expected.charAt(i) != actual.charAt(i)) {
                        System.out.println("Difference at position " + i + " expected " + expected.charAt(i) + " but got " + actual.charAt(i));
                    }
                }
            }
        } else {
            System.out.println("succeeded.");
        }
    }
}
 
Zuletzt bearbeitet von einem Moderator:
Das ist mein Code. Brauche hilfe bei add und substract und ableitung
Java: 
public class Polynom {
    int a;
    int b;
    int c;
    int d;
   
   
    public Polynom(int d) {
        this.d=d;
    }
    /**
     * Konstruktor fuer Polynom mit Grad 1
     */
    public Polynom(int c, int d) {
        this.c=c;
        this.d=d;
    }
    /**
     * Konstruktor fuer Polynom mit Grad 2
     */
    public Polynom(int b, int c, int d) {
         this.c=c;
        this.d=d;
        this.b=b;
    }
    /**
     * Konstruktor fuer Polynom mit Grad 3
     */
    public Polynom(int a, int b, int c, int d) {
        this.a=a;
        this.c=c;
        this.d=d;
        this.b=b;
    }
    /**
     * Addiere ein weiteres Polynom auf die aktuelle Instanz.
     *
     * @param p Polynom, welches auf die aktuelle Instanz addiert werden soll
     */
    public void add(Polynom p) {
       
    }
 
    /**
     * Subtrahiere ein Polynom von der aktuellen Instanz.
     *
     * @param p Polynom, welches von der aktuellen Instanz subtrahiert werden soll
     */
    public void subtract(Polynom p) {
        // TODO
    }
    /**
     * Berechne den Wert des Polynoms an der uerbgebenen Stelle x.
     *
     * @param x Wert von x
     * [USER=49078]@Return[/USER] Resultat der Berechnung an der Stelle x
     */
    public int map(int x) {
        // TODO
        return 0;
    }
    /**
     * Berechne die Ableitung eines Polynoms und gebe das Ergebnis als neue Instanz/neues Objekt zurueck.
     *
     * @param p Polynom dessen Ableitung berechnet werden soll
     * [USER=49078]@Return[/USER] Neues Polynom, welches die Ableitung des Polynoms p darstellt
     */
    public static Polynom derivation(Polynom p) {
        // TODO       
        return null;
    }
    /**
     * Erzeugt eine lesbare Darstellung des Polynoms (z.B. 8*x^3 + 9*x^2 + 6*x).
     * Weitere Beispiele finden Sie in den beiliegenden Tests.
     *
     * [USER=49078]@Return[/USER] Polynom als lesbare darstellung als String-Objekt.
     */
    public String toString() {
        // TODO
        return "";
    }
}
 
Zuletzt bearbeitet von einem Moderator:
Zu "add": Na überleg doch mal. Wenn du die (a, b, c, d)-Koeffizienten des Polynoms `ax³ + bx² + cx + d` hast, und du addierst jetzt die Koeffizienten (e, f, g, h) dazu, die dem Polynom `ex³ + fx² + gx + h` entsprechen. Was hast du dann als Ergebnis?
Oder als einfachere Aufgabe mit konkreten Werten: Was ist das Ergebnis von `2 + 3`? Richtig: 5. Und `2` kann ja gesehen werden als das Polynom: `0x³ + 0x² + 0x + 2`, sowie `3` als das Polynom `0x³ + 0x² + 0x + 3`. Vielleicht noch ein Beispiel: `2x + 3x`? Richtig: `5x`. Und `2x + 1` + `3x + 2`?
Ich hoffe, das grundlegende Prinzip sollte jetzt klar geworden sein. 🙂
Bezüglich "derivation": Das ist 11./12. Klasse Stoff Differentialrechnung. Also einfach Ableitung eines Polynoms.

Einfachste Schul-Algebra. Das ist noch weit von Uni-Level entfernt. 🙂
 
das üroblem ist wie bekomme ich die werte vom objekt Polynom p in die toadd Methode rein?
ich habe das objekt Polynom p übergeben bekommen und das ist wieder eine polynomgleichung des dritten grades und dieses objekt soll ich auf das vorherige addieren. mein Problem ist wie bekomme ich da die werte raus aus dem übergebenen objekt polnyom p? ich hatte vor das objekt polyno p zu casten und dann eine get Methode für alle Variablen im P zu returnen umso darauf zuzugreifen aber leider ist dies zu aufwendig. Gibt es eine alternative?
 
Java: 
public void add(Polynom p) {
  System.out.println(p.a); // <- gibt 'a' von 'p' aus
  // Jetzt musst du natürlich das machen, was eigentlich in 'add' erwartet wird
}
 
httpdigest hat gesagt.:
Java: 
public void add(Polynom p) {
  System.out.println(p.a); // <- gibt 'a' von 'p' aus
  // Jetzt musst du natürlich das machen, was eigentlich in 'add' erwartet wird
}
Zum Vergrößern anklicken....
public void add(Polynom p) {
a = a + p.a;
b = b + p.b;
c = c + p.c;
d = c + p.d;
}

So habe ich das gemacht jetzt ?
 
map ist die Berechnung der Formel mit x als Parameter.
map(3) -> Gib Ergebnis von a * 3^3 + b * 3^2 + c*3 + d

Bei der Ableitung erstellst du ein neues Polynom. Beim neuen Polynom ist a immer 0. b vom neuen Polynom ist dann 3 * a usw
 
habe den fehler längst geändert bei der letzten Zuweisung aber verstehe das mit der Ableitung nicht bei int map nicht genau?

ich habe das so gemacht jetzt
this.a = a*x*x*x;
this.b = b*x*x;
this.c = c*x;
this.d = d;
int result = a + b + c + d;

return result;
 
Nein Map ist einfach die Berechnung deines Polynoms mit eingesetztem x (Parameter) für x.
Da ist nichts anderes als eine ausgeführte Berechnung. Keine Zuweisung, nur ein return

Und bei der Ableitung (derive) erstellst du ein neues Polynom.
 
MoxxiManagarm hat gesagt.:
Nein Map ist einfach die Berechnung deines Polynoms mit eingesetztem x (Parameter) für x.
Da ist nichts anderes als eine ausgeführte Berechnung. Keine Zuweisung, nur ein return

Und bei der Ableitung (derive) erstellst du ein neues Polynom.
Zum Vergrößern anklicken....
ist doch das ?


this.a = a*x*x*x;
this.b = b*x*x;
this.c = c*x;
this.d = d;
int result = a + b + c + d;

return result;
 
MoxxiManagarm hat gesagt.:
Nein Map ist einfach die Berechnung deines Polynoms mit eingesetztem x (Parameter) für x.
Da ist nichts anderes als eine ausgeführte Berechnung. Keine Zuweisung, nur ein return

Und bei der Ableitung (derive) erstellst du ein neues Polynom.
Zum Vergrößern anklicken....
public int map(int x) {
this.a = a*x*x*x;
this.b = b*x*x;
this.c = c*x;
this.d = d;
int result = a + b + c + d;

return result;
}
das hier
 
Nein, du solltest a keinen neuen Wert zuweisen. Damit veränderst du das Polynom selbst ja. Du willst aber das Polynom nur berechnen, nicht verändern.
 
public int map(int x) {


int result = a*x*x*x + b*x*x + c*x + d;

return result;
}

so geht aucgh oder? ist meine toAdd Methode auch nicht falsch dann?
 
Führe ihn einfach aus, der sagt dir das Meiste... Ansonsten der Test hat verschiedene Polynome initial. @test wird durchgeführt beim Run. In der Methode steht welche Polynome vewendet werden und was erwartet wird.
 
Beispiel:

Java: 
Polynom p5 = new Polynom(8, 9, 6, 0);
    Polynom p6 = new Polynom(0, 2, 5, 8);

@Test
    public void add1() {
        p6.add(p5);
        assertEquals("8*x^3 + 11*x^2 + 11*x + 8", p6.toString(), "add");
    }

Das Ergebnis wird auf Basis von p6 asserted. Also hält p6 das Ergebnis. Wäre es ein neues Polynom würde es heißen:
Java: 
@Test
    public void add1() {
        Polynom p = p6.add(p5);
        assertEquals("8*x^3 + 11*x^2 + 11*x + 8", p.toString(), "add");
    }
 
achso verstehe also ändern wir die Zuweisung so gesehen, verstehe aber wie lese ich das bei int map also den x wert? anhand vom test ?
 
Eventuell garnicht. Es macht einfach nur keinen Sinn das Polynom bei einer einfachen Berechnung zu verändern. Vielleicht willst du das Gleiche Polynom ja nochmal verwenden und für ein anderes x ausrechnen.
 
MoxxiManagarm hat gesagt.:
Eventuell garnicht. Es macht einfach nur keinen Sinn das Polynom bei einer einfachen Berechnung zu verändern. Vielleicht willst du das Gleiche Polynom ja nochmal verwenden und für ein anderes x ausrechnen.
Zum Vergrößern anklicken....
Bro wie mache ich das x bei der Ableitung ? Ich weiß nicht wie ich das x mit einbeziehen soll? Ich wollte das x einfach als ein String behandeln
 
Du "machst das x" überhaupt nicht bei der Ableitung. Die Ableitung soll einfach die Koeffizienten der ersten Ableitung des Polynoms `ax³ + bx² + cx + d` berechnen und daraus ein neues Polynom-Objekt bauen, mit eben den neuen Koeffizienten, die sich aus der Ableitung ergeben haben.

Fürs erste: Ermittle für das allgemeine Polynom `ax³ + bx² + cx + d` (ohne jetzt konkrete Werte für a, b, c oder d zu haben) die Ableitung. Also rein symbolisch auf Papier.
 
"ax³ + bx² + cx + d" speicherst du in der Form garnicht, du speicherst nur a b c d und weißt, dass a der Wert vor x^3 ist. Für die Ableitung verwendest du die Produktregel
Demnach ist f'(x) = (3*a) x^2 + (2*b) x + c

Du hast ein vollkommen neues Polynom mit a = 0 und einem neuen b c d in Abhängigkeit von den vorherigen a b c.
Demnach ist das b vom neuen Polynom a*3 vom alten Polynom usw.
 
Vielleicht hilft dir das noch:

Java: 
public static Polynom derivation(Polynom p) {
    return new Polynom(/*new a*/, /*new b*/, /*new c*/, /*new d*/);
}

Ich habe schon so viel geschrieben, eigentlich könnte ich dir schon fast die Lösung anstatt der /**/-comments reinschreiben. Was du für a-d einsetzen musst steht in mehreren Vorgängerbeiträgen. Ich hoffe aber dass es bei dir nun endlich mal Klick macht und du die Zeile selber vervollständigen kannst.
 
MoxxiManagarm hat gesagt.:
Vielleicht hilft dir das noch:

Java: 
public static Polynom derivation(Polynom p) {
    return new Polynom(/*new a*/, /*new b*/, /*new c*/, /*new d*/);
}

Ich habe schon so viel geschrieben, eigentlich könnte ich dir schon fast die Lösung anstatt der /**/-comments reinschreiben. Was du für a-d einsetzen musst steht in mehreren Vorgängerbeiträgen. Ich hoffe aber dass es bei dir nun endlich mal Klick macht und du die Zeile selber vervollständigen kannst.
Zum Vergrößern anklicken....


public static Polynom derivation(Polynom p) {

return 3*p.a + 2*p.b + p.d;
}

zeigt leider ein fehler an dass er das objekt nicht in int konevrtieren kann
 
Nein du gibst ein neues Polynom-Objekt zurück. derivation heißt die statische Methode. Auf Deutsch heißt derivation soviel wie ableiten. Es ist also deine Ableitungsmethode
 
derivation ist nur der Name der Funktion. Der Parameter und die Rückgabe sind vom Typ Polynom:
Code: 
Polynom derivation(Polynom eingabe)
Das, was vor dem Methodennamen steht, ist der Typ der Rückgabe, das was in den Klammern steht, sind Typen und Namen der Parameter (hier nur ein Parameter vom Typ Polynom mit dem Namen eingabe).
 
mihe7 hat gesagt.:
derivation ist nur der Name der Funktion. Der Parameter und die Rückgabe sind vom Typ Polynom:
Code: 
Polynom derivation(Polynom eingabe)
Das, was vor dem Methodennamen steht, ist der Typ der Rückgabe, das was in den Klammern steht, sind Typen und Namen der Parameter (hier nur ein Parameter vom Typ Polynom mit dem Namen eingabe).
Zum Vergrößern anklicken....
Ja aber er gibt doch so gesehen ein neues polybom Objekt Namens derivation zurück ?
 
Aber du solltest doch auch langsam mal an die toString Methode machen. Von allen Methoden die du ergänzen sollst ist das entsprechend den Tests nämlich die Komplexeste. Alles andere sind 1-4 Zeiler.

Natürlich wäre es schön, wenn du einfach schreiben könntest:
Java: 
return a + "*x^3 + " + b + "*x^2 + " + c + "*x + " + d;

Aber es sind verschiedene Fälle zu betrachten wie z.B.
0-Werte & Negative Werte

Ja aber er gibt doch so gesehen ein neues polybom Objekt Namens derivation zurück ?
Zum Vergrößern anklicken....
Nein das Polynom hat keinen "Namen" in dem Sinne.
 
Wer weiß, vielleicht magst du ja noch weiter gehen, falls der Groschen irgendwann mal bei dir fällt.

Hier ein paar Ideen, vielleicht helfen Sie auch beim Verständnis...
Java: 
/**
 * Provides the order of the polynom
 */
public int getOrder() {
    if(a != 0) return 3;
    if(b != 0) return 2;
    if(c != 0) return 1;
    return 0;
}

/**
 * Multiplicates two polynoms, if the resulting order is not higher then 3
 */
public void mult(Polynom p) throws IllegalArgumentException {
    if(getOrder() + p.getOrder() > 3) throw new IllegalArgumentException("Result order not capable.");
 
    this.a = this.d * p.a + this.c * p.b + this.b * p.c + this.a * p.d;
    this.b = this.d * p.b + this.c * p.c + this.b * p.d;
    this.c = this.d = p.c + this.c * p.d;
    this.d = this.d * p.d;
}

/**
 * Checks, if the given x is a null point. f(x) = 0
 */
public boolean isNullPoint(int x) {
    return map(x) == 0;
}

/**
 * Provides any null point in the given range low <= x <= high
 */
public int guessNullPoint(int low, int high) throws NoSuchElementException {
    for(int x = low; x <= high; x++) {
        if(isNullPoint(x)) return x;
    }
 
    throw new NoSuchElementException("No integer null point in the given range.");
}

// public int[] getNullPoints() throws /*...*/ {}
// public void div(Polynom p) throws /*...*/ {}
 
Zuletzt bearbeitet:
Heyoka955 hat gesagt.:
Ja klar sprachlich ncijt aber von Aspekt der Programmierung. Also was da abläuft.
Zum Vergrößern anklicken....
Da ist es nicht anders. Du rufst eine Funktion mit Parametern auf und bekommst ggf. irgendwas zurück.

Ich versuch es mal einfach, wenn auch nicht ganz korrekt.

Das, was Du zurückbekommst, hat aber keinen Namen (genauso wenig, wie die Summe vorhin). Um dem Spaß einen "Namen zu verpassen", musst Du den Rückgabewert einer Variablen zuweisen.

Beispiel:
Java: 
int add(int a, int b) {
    return a + b;
}

Fall 1: Du führst folgendes aus:
Java: 
add(3, 4);

Dabei wird die Methode add mit den Parametern 3 und 4 aufgerufen. In der Methode wird 3 + 4 berechnet und das (namenlose) Ergebnis (7) zurückgegeben. Mit dem Ergebnis passiert weiter nichts, d. h. Du hast nach dieser Anweisung keine Möglichkeit mehr, auf das Ergebnis zuzugreifen. Das wäre in diesem Fall natürlich ziemlich sinnlos.

Fall 2:
Java: 
int ergebnis = add(3, 4);
Jetzt wird das Ergebnis (die 7) der Variablen "ergebnis" zugewiesen. Nach dieser Anweisung kannst Du auf das Ergebnis über die Variable "ergebnis" zugreifen. Zum Beispiel könntest Du das Ergebnis ausgeben lassen: System.out.println(ergebnis);

Fall 3:
Java: 
int ergebnis = add(add(3,4), 5);
Hier wird zuerst add(3, 4) ausgeführt. Dieser Aufruf liefert das (namenlose) Ergebnis 7. Daher wird im zweiten Schritt add(7, 5) ausgeführt. Dieser Aufruf liefert als Ergebnis dann 12, das abschließend der Variable ergebnis zugewiesen wird.

Dir muss klar sein, dass die Daten eines jeden Objekts im Hauptspeicher an jeweils anderer Stelle abgelegt werden. Die in der Klasse deklarierten Variablen existieren sozusagen für jedes Objekt separat.

Java: 
Polynom p1 = new Polynom(1,2,3,4);
Polynom p2 = new Polynom(5,6,7,8);
Hier werden zunächst zwei Instanzen (Objekte) der Klasse Polynom erzeugt. Das erste Objekt wird der Variablen p1 zugewiesen, das zweite der Variablen p2. Tatsächlich verhält es sich ein wenig anders, ich will Dich jetzt aber nicht zusätzlich verwirren. Wichtig ist: mit p1 und p2 kannst Du auf zwei verschiedene Objekte zugreifen.

Mit p1.a = 10; würde man also die Variable a von Objekt p1 verändern. Die Variable a von Objekt p2 dagegen bliebe unverändert.
 
Zuletzt bearbeitet von einem Moderator:

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Polynome
Antworten: 3
Polynome
Antworten: 22
Umwandlung von Text/Zeichen in Polynome
Antworten: 8
Polynome implementieren
Antworten: 3
Polynome
Antworten: 3

Zurück
Oben