# Differtialrechnung



## Stefan3333 (15. Apr 2004)

Hallo,

ich habe ein kleines Projekt angefangen und bräuchte einen Tip wie es weiter gehen könnte. Zur Zeit habe ich zwei Klassen programmiert. Die eine stellt ein 2D Koordinatensystem dar. Hier übergibt man Funktionen und kann sie zeichnen lassen. Die andere ist eine Klasse die einen String, beispielsweise String test = "2*sin(x-PI)/7^x"; interpretieren und berechnen kann.

Das klappt auch wunderbar. Jetzt möchte ich noch die Differtialrechnung umsetzen. Ableitungen, Stammfunktionen, Nullstellen usw. Hat jemand eine Idee wie man soetwas anstellen könnte? Kann man beispielsweise die Ableitungen Interpolieren?

Bin dankbar für jeden Tip


----------



## Beni (15. Apr 2004)

Wenn du die Operationen als Klassen implementiert hast, ist es relativ einfach (glaub mir, habs mal gemacht).
Jede Operation wird nach bestimmten Regeln abgeleitet (siehe Formelbuch), die implementierst du. Und wenn du noch die Kettenregel miteinbeziehst, geht das vonalleine.

Ich hab das etwa so gelöst (als Pseudocode):

```
public class Term{

Term term = getTerm();
  public Term ableitung(){
    Term left, right = ...
    Operation operation = ...

    return operation.ableiten( left, right );
  }
}
```

Als Beispiel die Multiplikation:
	
	
	
	





```
public class Multiplikation{
  public Term ableiten( Term left, Term right ){
    Term leftAbleitung = left.ableitung();
    Term rightAbleitung = right.ableitung();

    Term tLeft = ( left, this, rightAbleitung );
    Term tRight = ( leftAbleitung, this, right );

    return new Term( tLeft, new Addition(), tRight );
  }
}
```

Hoffe das gibt dir eine Idee

mfg Beni


----------



## Stefan3333 (15. Apr 2004)

Also ich weis nicht ob ich dich richtig verstehe aber ist das nicht wahnsinnig umfangreich wenn man versucht alle Regeln und Sonderfälle die es geben kann mit einzubeziehen. Man stelle sich vor ein Benutzer, so ist es bis jetzt, gibt eine beliebige Funktion(String wie oben) ein. Ich hole mir nun alle Operatoren und Operanden raus und wandel sie zur Berechnung in die Postfix Notation um. Danach wird das x eingesetzt und der Funktionswert berechnet. So mache ich das bisher.

Lautet die Funktion y=f(x)=2*x^2-1 wäre das ja noch übersichtlich aber was ist mit komplexeren Funktion zB sin,cos,tan,Wurzeln,log,Beträge und und und ....

Schafft man die Ableitungen wohl auch noch durch Implementierung der einzelnen Regeln?


----------



## Stefan3333 (15. Apr 2004)

Ähm, sorry...aber in welchem Forum wäre meine Frage eigentlich am besten aufgehoben?


----------



## stev.glasow (15. Apr 2004)

Stefan3333 hat gesagt.:
			
		

> Ähm, sorry...aber in welchem Forum wäre meine Frage eigentlich am besten aufgehoben?


In Algorithmen und Datenstrukturen (Programmierung Allgemein).


----------



## Beni (15. Apr 2004)

Stefan3333 hat gesagt.:
			
		

> Also ich weis nicht ob ich dich richtig verstehe aber ist das nicht wahnsinnig umfangreich wenn man versucht alle Regeln und Sonderfälle die es geben kann mit einzubeziehen. Man stelle sich vor ein Benutzer, so ist es bis jetzt, gibt eine beliebige Funktion(String wie oben) ein. Ich hole mir nun alle Operatoren und Operanden raus und wandel sie zur Berechnung in die Postfix Notation um. Danach wird das x eingesetzt und der Funktionswert berechnet. So mache ich das bisher.
> 
> Lautet die Funktion y=f(x)=2*x^2-1 wäre das ja noch übersichtlich aber was ist mit komplexeren Funktion zB sin,cos,tan,Wurzeln,log,Beträge und und und ....
> 
> Schafft man die Ableitungen wohl auch noch durch Implementierung der einzelnen Regeln?



Die meisten Regeln habe sich mit 2 Zeilen Code ja wohl erledigt!

Sinus:  _sin x_  :arrow: _ cos x * x'_  ... und schon fertig

Ich weiss nicht genau, wie man das in der Postfix-Notation implementieren muss (ich arbeite lieber mit einem Tree).

Meine Erfahrung ist: das ganze auf einem hohen Abstraktionslevel halten (also z.B. _immer _mit einem Interface "Operation" arbeiten, nur so als Beispiel), und dafür sorgen, dass die Hauptarbeit passend aufgeteilt wird (Nein, nicht jede Operation muss die Multiplikationsregeln kennen. Dafür sollte sich jeder Term selber ableiten können (Rekursion... ein Wundermittel)

Und weitere "Spezialfälle" sind mir nicht bekannt (P.S. und was in der Schule gross als Spezialfall angekündigt wird, ist meistens überhaupt nicht speziell. Das merkst du, sobald du es implementieren willst (plötzlich erscheint dir ein "if" sehr überflüssig -> ein Speziallfall der keiner war  )) 

Ich geb dir mal ein Beispiel, wie einfach ich den Sinus implementieren konnte:

```
public SCalcable ableitenS ( SCalcable [] a, boolean [] aStatic, String name,
                              Hashtable variablen, SCalcable [] b,
                              boolean [] bStatic ) throws IndefinException{
    if ( bStatic[0] ) // Optimierung: die Ableitung von cos "konstant" ist 0.0
      return new SParameter (0.0);
    else{
      SKlammer klammer = new SKlammer ( Cosinus.getStaticInstanc(), (SCalcable)b[0].clone() );
      return SKlammer.kettenRegel( klammer, b[0], name, variablen );
    }
  }
```

P.S. die Implementation der Kettenregel verwendet Rekursion, und ist auch mit 5 Zeilen geschrieben.

Also: lass dich nicht entmutigen!

Beni


----------



## Phaxx (16. Apr 2004)

Sorry, wenn ich mich hier einmische!
Habe aber zu deinem (Beni) letzten Post eine Frage...

Wir lernen im Studium Java und haben gerade Interfaces behandelt. Nur ist mir der Nutzen nicht ganz klar. Wo ich den Nutzen sehe, ist wenn mehrere Leute an einem Projekt arbeiten, damit man Implementierung und Verwendung von Klassen klar trennen kann. 
Du hast nun in diesem Zusammenhang geraten ein Interface zu benutzen. Könntest du den Sinn etwas erörtern, vielleicht wird mir dann vieles klar! 

Danke!
Phaxx

P.S. Habe auch schon diesen Thread gelesen, wo es schon einmal ein Erklärungsversuch gab. Aber in diesem î Zusammenhang hier kann ich's mir wieder ganz und gar nicht erklären...  :cry:


----------



## Phaxx (19. Apr 2004)

> Habe aber zu deinem (Beni) letzten Post eine Frage...


Beni (oder sonst wer), würde mich über eine Antwort freuen...  
In verschiedenen Büchern ist zwar die Implementierung von Interfaces klar erklärt, der Sinn wird mir aber einfach nicht klar...


----------



## Beni (19. Apr 2004)

Die Frage ist so verdammt schwer zu beantworten (oder meine Schreibkünste so verdammt schlecht...).

Interfaces haben den Vorteil, dass sie eine Schnittstelle erzeugen, die frei von jeglichen "Vorurteilen" und "Schnickschnack" ist.

Ein Interface schreibt einige Methoden vor (meistens gibt es eine sehr lange Dokumentation zu einer einzigen Methode), welche von absolut jederman implementiert werden können, ohne dass er gross Vorkenntnisse besitzen muss. (womit wir beim Punkt "Personen" sind).

Ich benutze manchmal auch programmintern Interfaces, wo theoretisch keine Interfaces notwendig wären. Z.B. müssen meine GUI-Klassen oft Interfaces implementieren, sobald sie mit den Daten-Klassen interagieren wollen. (z.B. ein Listener).
Das hat den Vorteil, dass man sehr schnell eine Klasse durch eine andere ersetzen kann, oder was neues hinzufügen. Denn Interfaces sind extrem flexibel, weil ein Interface oft nur 1 oder 2 Methoden vorgibt, und das kann man sehr schnell implementieren.

Und dass eine Klasse mehrere Interfaces implementieren kann, ist natürlich auch noch ganz praktisch.


----------



## Phaxx (19. Apr 2004)

Danke für die Erklärung! Ich denke, ich werde das erst mit der Zeit verstehen, jetzt tu ichs noch nicht...    :lol: Ich kann dir zwar folgen, wofür du sie verwendest, allerdings sehe ich als Haupteigenschaft der Interfaces vor allem, dass ich das, was ich später in der Klasse ausführlich schreibe, vorher im Interface "grob zusammenfasse". 
Aber du musst nun kein erneuter Erklärungsversuch starten, ich wirds schon irgendwann begreifen!  ???:L


----------

