================================================================================ = Autor: Mario SCHNEPF = MatrklNr: e0225056 = E-Mail: ma_s@gmx.at / e0225056@student.tuwien.ac.at = Datum: 15. Jänner 2003 = ------------------------------------------------------------------------------ = Beispiel: 4112 = Beschreibung: Symbolisches Differenzieren = <== Eingabe: Eine Funktion wird eingelesen, wobei keine = Leerzeichen vorkommen dürfen = Differenziert wird nach dem ersten = (deutschen) Alphabetszeichen (keine = Umlaute), das nicht eine höhere Funktion = darstellt. Außer dieser Variable sind = keine andersnamigen Variablen erlaubt = ==> Ausgabe: die Funktion wir abgeleitet und zusammen- = gefasst = xxx Fehlerbehandlung: bei falscher Eingabe ==> FALSCHE EINGABE ================================================================================ Beschreibung ============ Eine Funktion wird eingelesen, differenziert, vereinfacht und ausgegeben. Die Funktion darf aus einzelnen Termen bestehen, die eine der folgenden Formen haben müssen: <Koeffizient><x><Exponent> wobei <Koeffizient> (konstanter multiplikativer Faktor) und <Exponent> zw. 1 und 9 (inklusive) liegen, Weglassen des Koeffizienten oder Exponenten entspricht einer 1 <Zahl> wobei 1 <= <Zahl> <= 9 e(<Zahl><x>) sin(<Zahl><x>) cos(<Zahl><x>) wobei <Zahl> bei e, sin und cos im Inneren der Funktion optional ist All diese Ausprägungen werden ab nun mit Term bezeichnet. Kombiniert werden können diese Terme mit + und -. Differentationsregeln: (<Koeffizient><x><Exponent>)' => <Koeffizient>*<Exponent><x><Exponent>-1 für <Exponent> größer als 1 (<Koeffizient><x>1)' oder (<Koeffizient><x>)' => <Koeffizient> (<Zahl>)' => fällt gänzlich weg e(<Zahl><x>)' => <Zahl>e(<Zahl><x>) sin(<Zahl><x>)' => <Zahl>cos(<Zahl><x>) cos(<Zahl><x>)' => -<Zahl>sin(<Zahl><x>) (Ist bei e, sin oder cos keine Zahl vor der Variable <x> wird die erste <Zahl> (also die innere Ableitung) bei der Berechnung der Ableitung weggelassen) (Term1+Term2)' => Term1' + Term2' (Term1-Term2)' => Term1' - Term2' Eine Funktion darf aus maximal 6 Termen bestehen. Vereinfacht wird nur anhand folgender Regeln werden: Alle Terme, die bis auf den Koeffizienten gleich sind, werden zusammengefasst, indem die Koeffizienten addiert bzw. subtrahiert werden. Beim Zusammenfassen von Termen gilt: Terme werden an jene Stelle "vorgezogen" an der sie vor der Vereinfachung als erstes aufgetreten sind. Eingabedaten: ============= Eine Funktion, die aus den zuvor spezifizierten Termen bestehen darf. Innerhalb der Funktion sind keine Leerzeichen erlaubt. Differenziert wird nach nach dem ersten erkannten (deutschen) Alphabetszeichen (keine Umlaute), das nicht eine höhere Funktion (wie sin, cos, e) darstellt. Außer dieser Variable sind keine andersnamigen Variablen erlaubt. Ausgabedaten: ============= Ausgegeben wird die resultierende Funktion, die laut vorigen Regeln differenziert und vereinfacht wurde. Kürzt sich alles heraus wird einfach 0 ausgegeben. Danach kommt ein Zeilenvorschub Fehlerbehandlung: Genügt die Eingabe nicht den Erfordernissen, wird nur eine Fehlermeldung "FALSCHE EINGABE" gefolgt von einem Zeilenvorschub auszugeben. ==== Main.java ================================================================= = public static void Main() = erzeugt nur ein symbdiff-Objekt, welches dann den Rest erledigt (Eingabe, = Auswertung, Ausgabe) ================================================================================ ==== symbdiff.java ============================================================= = private void Input() = liest einen String ein und speichert diesen im String "Eingabe" = ------------------------------------------------------------------------------ = private void doTeilstringsErzeugen() throws EprogException = diese Methode splittet den String "Eingabe" in jene Teilstrings auf die = entweder durch "+" oder "-" getrennt sind, wobei "+" bzw. "-" zum 2.ten Teil = kommt. = Beispiel: "aaa+bbb-ccc" ==> "aaa" "+bbb" "-ccc" = die Teilstrings werden in der "TeilString"-Hashtable abgespeichert = ------------------------------------------------------------------------------ = private void erzeugeTerme() throws EprogException = die in der "TeilString"-Hashtable abgespeicherten Strings werden versucht in = Terme umzuwandeln wobei diese gleich auf syntaktische-Korrektheit überprüft = werde - die umgewandelten Terme werden in der "Terme"-Hashtable abgeseichert = zusätzlich wird in der "Art"-Hashtable an der gleichen Stelle (mit dem = gleichen Index wie "Terme") ein String abgespeichert der anzeigt um welche = Art von Objekt (sincos, euler, zahl) es sich an genau dieser Stelle in der = "Terme"-Hashtable handelt = ------------------------------------------------------------------------------ = private void doAbleiten() throws EprogException = die in "Terme" abgespeicherten Terme werden der Reihe nach ausgelesen und = einzeln abgeleitet (es wird für das jeweilige Unter-Objekt die entsprechende = Methode "doAbleitung" aufgerufen = ------------------------------------------------------------------------------ = private void doVereinfachen() throws EprogException = die in "Terme" abgespeicherten Terme werden paarweise miteinander verglichen = sollte man zwei zusammenfassen können, so wird dieser an die erste Stelle = vorgezogen und der zweite Term wird "gelöscht" in dem alle Werte auf "0" bzw = auf "" gesetzt werden = ------------------------------------------------------------------------------ = private void printAusgabe() = für alle "Terme" wird die entsprechende Methode "erzeugeString" aufgerufen = und so der "Ausgabe"-String zusammengestückelt. Anschließend wird dieser = String ausgegeben. ================================================================================ ==== Global.java =============================================================== = diese Klasse enthält "Konstanten" und "Variablen auf die von überall aus = zugegriffen werden kann (quasi globale "Konstanten" und "Variablen"), dadurch = befinden sich hier auch sämtliche "Konstanten" und "Variablen" womit das = Anpassen des Programms vereinfacht wird ================================================================================ ==== Term.java (euler.java, sincos.java, zahl.java) ============================ = abstract void doAbleitung() throws EprogException; = führt für das entsprechende Sub-Objekt die Ableitung nach der Variable = Global.V durch = ------------------------------------------------------------------------------ = abstract void checkFormatierung() throws EprogException; = überprüft ob der bei der Erzeugung des Sub-Objekts übergebene String = der geforderten Syntax entspricht = ------------------------------------------------------------------------------ = abstract String erzeugeString (); = setzt die Variablen des Sub-Objekts zu einen "sinnvollen" String zusammen = zb: "+1x1" ==> wird so ausgegeben: "+x" = ---- (nur Term.java) --------------------------------------------------------- = public int erzeugeInt(String Temp) throws EprogException = der übergebene String wird versucht in eine Zahl umzuwandeln = wenn sich die Zahl innerhalb der Grenzen (1 <= zahl <= 9) und ganzzahlig ist = wird die Zahl zurückgegeben - andernfalls -1 ================================================================================