Polynome

[Guest]

Hallo!

Habe eine Übungsaufgabe zum Thema Polynome bekommen.

"Erstellen Sie eine Klasse Polynom, die Polynome mit double-Koeffizienten als Ergebnistyp
modelliert. Ein Objekt p der Klasse Polynom soll über folgende Methoden verfügen:"

u.a. auch: "addiere(Polynom q), addiert zu p das Polynom q"

Dies bedeutet, dass die Methode addiere mit dem Parameter Klasse Polynom q gestartet
wird. Was ist damit genau gemeint, wie funktioniert dies und wie könnte sowas aussehen.
Wie das addieren funktioniert ist mir klar, mathematik gesehen, aber mich irritiert der
Parameter Polynom q

Dazu habe ich u.a. schon folgenden Code geschrieben

public class Polynom {

    /** Koeffizienten: p(x) = k[n]x^n + k[n−1]x^(n−1) + ... +k[1]x + k[0]
     *  mit n = length(a) - 1
     */
    private double[] p;

    public static void main(String[] args) {
        // TODO code application logic here
}
    /**
     * Standard Konstruktur
     */
    public Polynom() {
        this(null);
    }
    
    /**
     * Konstruktor mit Koeffizienten
     */
    Polynom(double[] k) {
        if (k == null) {
            p = new double[0];
        } else {
            p = new double[k.length];
            for (int i = 0; i<k.length; i++) {
                p[i] = k[i];
            }
        }
    }
    
    public double[] getPolynom() {
        return p;
    }
    
    public void addiere(Polynom q) {
        
    }
    
}

Für Hilfe bin ich dankbar!

Viele Grüße
Daniel

 

[SlaterB]

wie kann dich das irritieren?

stelle dir eine einfachere Klasse Zahl vor
jetzt willst du eine andere Zahl dazuaddieren,
also addiere(Zahl z)

ohne Parameter gehts nicht, denn dann hättest du ja nix zum addieren

du sollst einfach zwei Polynome addieren,
eines ist das Objekt selber, das andere der übergebene Parameter

 

[Guest]

Danke! Jetzt hab ich es verstanden. So sieht mein Code bis jetzt aus.
Sollte man eigentlich die Methode rekusriv schreiben, wenn es sich anbietet?
Oder ist dies eine Glaubenssache?

Viele Grüße + danke nochmals
Daniel

public class Polynom {

    /** Koeffizienten: p(x) = k[n]x^n + k[n−1]x^(n−1) + ... +k[1]x + k[0]
     *  mit n = length(a) - 1
     */
    private double[] p;

    public static void main(String[] args) {
        
    }
    
    /**
     * Standard Konstruktur.
     */
    public Polynom() {
        this(null);
    }
    
    /**
     * Konstruktor mit Koeffizienten.
     */
    Polynom(double[] k) {
        if (k == null) {
            p = new double[0];
        } else {
            p = new double[k.length];
            for (int i = 0; i<k.length; i++) {
                p[i] = k[i];
            }
        }
    }
    
    public double[] getPolynom() {
        return p;
    }
    
    public void addiere(Polynom q) {
        double[] r = q.p;
       
        if (r.length<=p.length) {
            for (int i = 0; i <= r.length-1; i++) {
            p[i] += r[i];
            }
        }
        if (r.length > p.length) {
            double[] u = new double[r.length];
            for (int i = 0; i <= r.length-1; i++) {
                u[i] += r[i];
                if (i <= p.length) {
                    u[i] += p[i];
                }
            }
            p = u;
        }
    }
    
    public void ableitung() {
        if(p.length-1 <= 0) {
            // Polynom Ordnung 1
            double[] q = new double[1];
            q[0]=0;
            p = q;
        } else {
            // Alle andere Polynome
            double[] q = new double[p.length-1];
            int i = p.length-1;
            for (int j = 0; j <= p.length-2; j++) {
                q[j] = p[j]*i;
                i--;
            }
            p = q;
        }
    }

    public void integral() {
        if (p.length-1 <= 0) {
            double[] q = new double[2];
            q[1]=p[0];
            p = q;
        } else {
            double[] q = new double[p.length+1];
            int i = q.length-1;
            for (int j = 0; j <= p.length-1; j++) {
                q[j] = p[j]/i;
                i--;
            }
            p = q;
        } 
        
    }
    
    public double auswerten(double x) {
        // Hornerschema
        double s = 0.0;
        for (int i = 0; i <= p.length-1; i++) {
            s = s*x + p[i];
        }
        return s;
    }


}

 

[SlaterB]

i <= r.length-1

lesbarer und durchaus üblich ist

i < r.length

------

Rekursion am besten vermeiden, wo es eine einfache Schleife tut,

Rekursion eigentlich nur, wenn der iterative Weg sehr umständlich wäre,
z.B. beim Durchlaufen eines Baumes (Stamm hat 5 Äste, jeder Ast 5 Blätter), falls du dir darunter etwas vorstellen kannst,
iterativ müsste man sich in der Schleife verschiedene Dinge merken:
z.B. Rekursionstiefe, Position in JEDER Tiefe von Anfang an

wenn man merkt, dass man einen einfach Fall hat,
z.B. nur eine Liste ohne Verzweigung durchläuft,
dann macht Rekursion weniger oft Sinn