---------------------[  das projekt Vektoren  ]------------------------










-------[  i] inhalt

	0. [ einleitung ]
	  0.1 < java.util.Vector >
	1. [ Vektoren ]
	  1.1 < quickSyntaxCheck() >
	  1.2 < termsToTermv() >
	  1.3 < convertVectors() >
	  1.3 < processPrefixes() >
	  1.3 < convertScalars() >
	  1.3 < solveBrackets() >
	  1.3 < calculate() >
	  1.3 < giveToCalculator() >

	appendix a: zeit zu knapp





-------[  0.] einleitung

	im sourcecode der klasse Vektoren habe ich erwaehnt, dass ich
mit diesem resultat eigentlich nicht zufrieden bin.  der grund ist,
dass ich das beispiel so richtig nach studentenart geloest habe (ie.
nach dem abholen erst mal eine weile liegengelassen, am wochenende so
richtig feiern gegangen und 36 stunden vor dem abgabetermin das erste
mal etwas daran gearbeitet).  schlaegt sich sehr stark in der qualitaet
des codes under ausfuehrlichkeit der dokumentation hin.  darum ist auch
die wichtigste aussage an der doku, dass ich jederzeit per email
(patrick.k@rocketmail.com) oder ICQ (55690660) zu erreichen bin, falls
mich jemand was fragen moechte (sollte ich offline sein, trotzdem
schreiben, einmal am tag gehe ich sicher online).



---< 0.1> java.util.Vector

	ich habe keinen parser im allgemeinen sinn geschrieben, sondern
gehe die eingabe einfach so oft durch bis nur noch ein wert da ist.
dafuer ist die klasse Vector sehr nuetzlich.  es handelt sich dabei
grundsaetzlich um ein array von objekten.  die groesse ist allerdings
vollkommen variabel und man kann zum beispiel auch elemente in der mitte
des Vectors herausloeschen.

	das die klasse Vector heiszt ist fuer mein programm eigentlich
ziemlich laestig, da ich ja mit vektoren rechnen muss.  diese beiden
sachen habe nichts miteinander zu tun.  ich hoffe es ist nicht zu
verwirrend.





-------[  1.] Vektoren

	die grundidee bei meinem programm ist es den ausdruck solange
zu vereinfachen, nur noch skalare, vektoren und operatoren im Vector
gespeichert sind.  klammern sind ja eigentlich auch nur ein einziger
wert, den man eben vorher ausrechnen muss.

	dann werden immer ein operator und zwei operanden an den
Calculator uebergeben.  das ergebnis wird gespeichert, die anderen
drei objekte koennen geloescht werden.  das wird gemacht bis nur noch
ein objekt im Vector ist, das ist dann das ergebeniss.



---< 1.1> quickSyntaxCheck()

	ist eine der zaehlvariablen einmal negativ, wurde eine klammer
zu gemacht, die garnicht geoeffnet wurde.  ist am ende des checks
eine der variablen ungleich null wurde eine der klammern nicht
zugemacht.



---< 1.2> termsToTermv()

	kopiert den eingelesenen term der als String vorliegt (terms)
in einen Vector (termv);



---< 1.3> convertVectors()

	der ganze Vector wird durchsucht.  wird eine oeffnende eckige
klammer gefunden muss es sich um einen vektor handeln.  nachdem alle
vektoren von einzelzeichen in objekte konvertiert wurden, sind schon
mal viel weniger elemente da (aus [1,2,3] (7 zeichen) wird 1 objekt).



---< 1.4> processPrefixes()

	in der spezifikation steht, man soll beachten, dass -[1,2,3]
gleich [-1,-2,-3] ist.  also heiszt ein ausdruck wie [1,2,3]+-[1,2,3]
nichts anderes als [1,2,3]+[-1,-2,-3].  es kann also sein, dass zwei
operatoren hintereinander durchaus legitim sind.  diese methode findet
solche faelle, wo vor einem vektor ein vorzeichen UND davor irgendein
operator steht und verbindet das vorzeichen mit dem vektor -> wieder
ein element weniger im Vector.



---< 1.5> convertScalars()

	gleiches prinzip wie bei den vektoren, nur ein bisschen
komplizierter, weil eine runde klammer ja nicht nur benutzt wird, um
skalare zu markieren.  man muss also auch das nachfolgende zeichen
betrachten.  ist es ein vorzecihen oder eine ziffer, handelt es sich
um einen skalar.  ist es keins von beiden und auch keine neue oeffnende
klammer oder ein vektor, stimmt etwas nicht mit der eingabe -> abbruch.



---< 1.6> solveBrackets()

	diese methode sucht sich sich jetzt alle klammernausdruecke
(skalare stehen ja jetztnichtmehr in klammern!) und wertet sie aus, so
dass anstelle des ausdrucks nur noch ein wert steht.



---< 1.7> calculate()

	calculate wurde ja schon von solveBrackets() benutzt.  war dabei
allerdings auf einen klammernausdruck beschraenkt.  klammern gibt es
jetzt keine mehr, also lasse ich calculate uber den gesamten Vector
laufen.

	calculate() speichert das ergebnis immer an der stelle wo der
erste operand gestanden ist und loescht die beiden objekte dahinter
(der operator und der zweite operand).  da zwei objekte aus dem Vector
geloescht werden muss die variable end um zwei erniedrigt werden, sonst
versucht calculate() noch elemente zu finden obwohl das ende des Vectors
schon erreicht ist.  das heiszt auch, dass am ende der methode die
variablen start und end gleich sein muessen (weill nur noch ein objekt
da sein darf).  ist das nicht der fall war die eingabe ungueltig.
(z.b.: (2)+(3)[1,2,3] wuerde zu (5)[1,2,3].  dann wuerden keine
operatoren mehr gefunden, aber es sind trotzdem noch zwei objekte da.)



---< 1.8> giveToCalculator()

	calculate() ermittelt nur die position an der ein operator
auftritt und uebergibt diese position an giveToCalculator().  diese
methode holt das objekt an der angegebenen position (der operator), das
objekt davor (der erste operand) und das objekt dahinter (der zweite
operand).  giveToCalculator() uebergibt diese drei objekte an den
Calculater, der dann dass ergebniss ermittelt.





appendix a: zeit zu knapp

	eigentlich wollte ich ja noch kurz auf die methoden scanVektor()
und scanScalar, sowie auf die klassen VectorObject und Calculator
eingehen, aber es wird schon knapp mit dem abgeben.  sorry.
							-->patrick

-- 
klaffenboeck patrick		/"\
patrick.k@rocketmail.com	\ /      ASCII Ribbon Campaign
ICQ# 55690660			 X   against HTML in email & vCards
				/ \