Analysis Programm mit OOP

hotblack

Hallo,
ich habe vor, ein Programm für Analysis zu schreiben, aber ich habe null Plan wie ich das in Klassen... splitten kann. Ich habe schon mal angefangen mit dem Prog (ohne OOP), will jetzt aber endlich mal konsequent versuchen OOP umzusetzen. Mein Problem ist jedes mal die Analyse, habe dazu auch ein paar Bücher gelesen. Meiner Meinung nach sind die Beispiele zu einfach gestaltet mit Hunden Katzen... oder Astronaut und Planet, Raumschiff
Kann mir jemand bei diesem Problem helfen.
Ein Analysisprog müsste ja wenigstens integrieren, ableiten und Nullstellen, Wendepkte und Extrema finden.
Dabei gibt es verschiedene Regeln fürs ableiten und integrieren. So weit so klar aber wie jetzt Klassen bilden

Vielen Dank für eure Antworten :xmas1:

JBeni

Eine Klasse für "+", eine Klasse für "-", ... eine Klasse für Konstanten...

Ich hab das mal so gemacht, und ableiten war damit kein Problem

DocJunioR

Also ne Möglichkeit wäre doch ne Klasse Funktion, die die Eigenschaften Maximum, Minimum und Wert(x) hat.
Außerdem müsste sie ne Methode besitzen, die f'(x) in Form der gleichen Klasse liefert.
Weiterhin sollte dann noch F(x) erstellt werden können.

Was man noch so braucht, musst du dann sehn..

Gregor

DocJunioR schrieb:

Weiterhin sollte dann noch F(x) erstellt werden können.

Das hört sich bei dir so einfach an.

Mein Matheprof wollte mir weismachen, dass man F(x) leichter erstellen kann als f'(x), denn es geht ja viel öfter. Also ist es ganz leicht.

btw.

interface Funktion
{
    double valueOf(double x);
}

public final AbgeleiteteFunktion implements Funktion
{
    public AbgeleiteteFunktion(Funktion f)    {...}

    public double valueOf(double x)
    {
        return differenzenQuotient(f.valueOf(x));
    }
}

Sowas rockt.
Jetzt kann man beliebig oft ableiten. (Wenn's gut geht )

Jester

Wie wär's wenn ne Funktion ne Methode anbietet, die die Ableitung zurückgibt? Und zwar wieder als Funktion... und wenn was nicht differenzierbar ist, dann schmeißt es ne exception. Zumindest Polynome müßte man damit ganz gut in den Griff kriegen. Bei Stammfunktionen isses schon nicht mehr so einfach, weil man nicht weiß welche Stammfunktion jemand haben will.

DocJunioR

Gregor schrieb:

DocJunioR schrieb:

Weiterhin sollte dann noch F(x) erstellt werden können.

Das hört sich bei dir so einfach an.

hab ich gesagt, dass es einfach ist?

Also meine letzte Kurvendiskussion hab ich *hmm* naja, mal abgesehen von denen in Kneipen, wenn ne Blondine vorbeiläuft vor 6 Jahren durchgeführt..

Gregor

Optimizer schrieb:

btw.

interface Funktion
{
    double valueOf(double x);
}

public final AbgeleiteteFunktion implements Funktion
{
    public AbgeleiteteFunktion(Funktion f)    {...}

    public double valueOf(double x)
    {
        return differenzenQuotient(f.valueOf(x));
    }
}

Sowas rockt.
Jetzt kann man beliebig oft ableiten. (Wenn's gut geht )

Mein Ansatz wäre da eher folgender:

public abstract class Function
{
   public abstract Function derive(final int var);
   public abstract Function simplify();
   public abstract double getValue(final double... vars);
   //...
}

...und dann davon mehr oder weniger direkt abgeleitet Klassen wie:

public final class SinFunction extends Function
{
   private final Function innerFunction;

   public SinFunction(final Function innerFunction)
   {
      this.innerFunction = innerFunction;
   }

   public final Function derive(final int var)
   {
      return new MultiplyFunction(new CosFunction(innerFunction),innerFunction.derive(var)).simplify();
   }

   public final Function simplify()
   {
      //... 
      //(Die Vereinfachung von mathematischen Termen ist ja schon
      // viel aufwändiger als das Bilden der Ableitung.)
   }

   public final double getValue(final double... vars)
   {
      return Math.sin(innerFunction.getValue(vars));
   }
}