# Wie schwer ist es ein Applet für Matheaufgaben zu erstellen?



## starfox (1. Sep 2008)

Hey ihr!

Ich möchte ein Java-Applet für leichte Matheaufgaben erstellen.
Nur habe ich ehrlich gesagt keinen Plan von Java... Schafft man das, wenn man sich ein wenig
einliest oder ist dafür monatelanges Pauken nötig?

Danke schonmal
starfox


----------



## 0x7F800000 (1. Sep 2008)

Und was soll man sich denn bitte unter einem "applet für leichte Matheaufgaben" vorstellen?


----------



## Ariol (1. Sep 2008)

http://www.java-forum.org/de/viewtopic.php?t=13378


----------



## starfox (2. Sep 2008)

Andrey hat gesagt.:
			
		

> Und was soll man sich denn bitte unter einem "applet für leichte Matheaufgaben" vorstellen?



Ich meinte Aufgaben mit den Grundrechenarten und vll noch Gleichungen lösen.

@Ariol
Oh je, das sieht ja doch recht kompliziert aus. Ich dachte das lässt sich einfach nach dem Prinzip "Antwort richtig/falsch" machen..


----------



## Der Müde Joe (2. Sep 2008)

wenn du das ganze auf einer Grammatik aufbaust ist es einfacher.
Nimm zB Antlr und erstell dir die Grammatik und lass dir parser und lexer etc erstellen. Grammatiken für antlr Rechner hats zur genüge im Netz der Rest ist noch GUI geplänkel.


----------



## 0x7F800000 (2. Sep 2008)

Naja, solche Sachen scheitern weder an java, noch an mathe. Die übersetzung der Formeln in Baumartige Java-Strukturen ist schon problematisch genug, aber eigentlich müsste das "vereinfachen" der Ausdrücke noch problematischer sein... Ich weiß ehrlichgesagt nicht, wie die CAS programme das eigentlich anstellen. ???:L


----------



## Der Müde Joe (2. Sep 2008)

> Baumartige Java-Strukturen ist schon problematisch genug,



naja..eben antlr


```
class PParser extends Parser;
options { buildAST=true; }

imaginaryTokenDefinitions : SIGN_MINUS SIGN_PLUS ;

expr    : LPAREN^ sumExpr RPAREN!;
sumExpr : prodExpr ((PLUS^|MINUS^) prodExpr)*;
prodExpr: powExpr  ((MUL^|DIV^|MOD^) powExpr)*;
powExpr	: signExpr (POW^ signExpr)?;
signExpr:  ( m:MINUS^ {#m.setType(SIGN_MINUS); }
            |p:PLUS^  {#p.setType(SIGN_PLUS);  }
           )? atom | SIN^ atom| COS^ atom | TAN^ atom | LOG^ atom | LN^ atom | LD^ atom | EUL^ atom |SQRT^ atom;
atom    :  INT | expr | CHAR;


class LLexer extends Lexer;
options {k=3;}

LPAREN: '(' ;
RPAREN: ')' ;
PLUS  : '+' ;
MINUS : '-' ;
MUL   : '*' ;
DIV   : '/' ;
MOD   : '%' ;
POW   : '^' ;
SQRT  : "sqrt"|"SQRT";
EUL   : 'e'|'E';
SIN   : "sin"|"SIN";
COS   : "cos"|"COS";
TAN   : "tan"|"TAN";
LN    : "ln"|"LN";
LOG   : "log"|"LOG";
LD    : "ld"|"LD";

protected CHARACTER:  (('_')* ('0'..'9')* ('a'..'z'|'A'..'Z')+ ('_')* ('0'..'9')*)+;
protected DOUBLE: ( '0'..'9' )+ ( '.' ( '0'..'9' )* )?;

INT : DOUBLE;
CHAR: CHARACTER;



class TreeWalker extends TreeParser;

expr returns [String r]
 {String a,b; r=null;}

  : #(PLUS a=expr b=expr)  	{ r=Calculator.getInstance().addition(a,b); } 
  | #(MINUS a=expr b=expr) 	{ r=Calculator.getInstance().sub(a,b); } 
  | #(MUL a=expr b=expr)   	{ r=Calculator.getInstance().multip(a,b); }
  | #(DIV a=expr b=expr)   	{ r=Calculator.getInstance().division(a,b); }
  | #(MOD a=expr b=expr)   	{ r=Calculator.getInstance().modulo(a,b); }
  | #(POW a=expr b=expr)   	{ r=Calculator.getInstance().power(a,b); }
  | #(SIN a=expr)	   	{ r=Calculator.getInstance().sin(a); }
  | #(COS a=expr)	   	{ r=Calculator.getInstance().cos(a); }
  | #(TAN a=expr)	   	{ r=Calculator.getInstance().tan(a); }
  | #(SQRT a=expr)         	{ r=Calculator.getInstance().sqrt(a);}
  | #(EUL a=expr)	   	{ r=Calculator.getInstance().euler(a); }
  | #(LOG a=expr)	   	{ r=Calculator.getInstance().logar(a); }
  | #(LN a=expr)           	{ r=Calculator.getInstance().ln(a);}
  | #(LD a=expr)           	{ r=Calculator.getInstance().ld(a);}
  | #(LPAREN a=expr)	   	{ r=Calculator.getInstance().addition(a,"0");}
  | #(SIGN_MINUS a=expr)   	{ r=Calculator.getInstance().multip("-1",a);}
  | #(SIGN_PLUS a=expr) 	{ r=Calculator.getInstance().addition(a,"0");}
  | i:INT { r=i.getText();}
  | q:CHAR {r=Calculator.getInstance().recognizer(q.getText());}
;
```

Grammatik schafft rechnen sogar mit variablen..wenn ich mich noch recht erinnere (ist schon so 4-5 Jahre her)

ANTLR hat noch irgend so ne Klasse ASTBuilder (lang ists her) oder so und schon ists getan


----------



## Marco13 (2. Sep 2008)

Man braucht keinen Parser, wenn man nur die Grundrechenarten machen will. Aber schon beim "Gleichungen lösen" wird's interessant.

Die Frage "Wie schwer ist es ein Applet für Matheaufgaben zu erstellen?" kann man ganz einfach beantworten: Das nicht unbedingt "schwer", aber du kannst es dir so schwer machen, wie du willst.


----------



## starfox (3. Sep 2008)

Wow, ich hab gerade versucht mich mit diesem Antlr vertraut zu machen bzw. mich einzulesen aber das scheint ja irre kompliziert zu sein   . Kann man sowas überhaupt in ein Java-applet einbinden?

Wo finde ich denn, für mich geeignete, Grammatiken?
Die Namen unter http://www.antlr.org/grammar/list sagen mir leider zu 95% nichts.  :roll:


----------



## Der Müde Joe (4. Sep 2008)

Ich habe dir mal ein Tutorial ausgegraben auf meiner HD...
Kapitel 8 erklärt den Ansatz eines Rechners. (würde aber schon alles lesen)
Meins da oben ist eine Erweiterung um Variablen.

http://www.java-forum.org/de/userfiles/user8713/antlr.pdf

EDIT:
Ist also so 2002 oder sowas..also nicht mehr ganz aktuell...aber viel wird sich wohl nicht geändert haben
in den Grundlagen.


----------



## starfox (4. Sep 2008)

Dank dir!

Werd mich da mal durchbeißen =)

Finde es aber schon ein bisschen verwunderlich dass es nicht wirklich viele tutorials zu Antlr gibt, wobei man bei Java oder anderen Sprachen von Tutorials erschlagen wird.


----------



## cui23 (4. Sep 2008)

Für Grundrechenarten brauchste doch zumindest ma keinen Parser und nix..

Zwei Eingabefelder, eine Auswahlliste oder sowas für den Operator, nen Lösen Knopf und ne Ausgabefläche.
Dann nen par If's in den Source-Code für die vier Fälle (vier Operatoren), das wars.
Das Gui-gepfrimel kann man sich anlesen, zumindest wenn man schonma iwas mit Programmierung am Hut hatte sollte das recht einfach sein..
Wenn nicht würde ICH ja nicht gleich mit Gui und Applet und allem anfangen aber jedem das seine^^

lg,
cui.


----------



## starfox (4. Sep 2008)

Hm ich glaube ihr habt mich mißverstanden.. bzw. ich hab mich nicht richtig ausgedrückt.

Ich will ein Applet kreieren, das quasi eine Lernhilfe ist. Man muss vorgegebene Aufgaben rechnen und dann die Lösung in so ein Applet eintippen. Dieses zeigt dann an ob die Lösung richtig oder falsch ist. Es muss aber auch in der Lage sein verschiedene Lösungen zu akzeptieren. (Die Lösung von Matheaufgaben kann oft verschieden ausgedrückt oder geschrieben sein)


----------



## 0x7F800000 (4. Sep 2008)

Du willst also in der Lage sein festzustellen, ob zB. sowas wie

```
ln(sqrt((a+b)/a))-ln(sqrt(1-b/a))
```
dasselbe ist wie

```
artanh(b/a)
```
?
Naja, wie gesagt, dazu muss man in der Lage sein, bestimmte Muster in den Formeln zu erkennen, auf diese irgendwelche Regeln anwenden, um zu irgendeiner "normalform" zu kommen, und die ausdrücke anschließend vergleichen. Dabei rettet dich kein Parser-generator mehr, weil es da eben nicht mehr ums parsen geht.

Ein ziemlich dreckiger Trick wäre natürlich, die beiden formeln zu parsen (also eingabe sowie das erwartete ergebnis) und die an paar hundert stellen auszuwerten. Wenn man dann keinen großen numerischen Unterschied feststellt, kann man mit einer gewissen Wahrscheinlichkeit annehmen, dass derjenige, der das eingetippt hat, in etwa wusste was er da tut, und ein richtiges ergebnis geliefert hat. Das kann allerdings auch ziemlich schief gehen, etwa wenn sich jemand den scherz erlaubt, statt zB "e^pi*x"  sowas wie "e^pi*x+0.0000000001" einzutippen, und dann trotzdem gesagt bekommt "ihre lösung ist richtig"


----------



## Wildcard (4. Sep 2008)

starfox hat gesagt.:
			
		

> Finde es aber schon ein bisschen verwunderlich dass es nicht wirklich viele tutorials zu Antlr gibt, wobei man bei Java oder anderen Sprachen von Tutorials erschlagen wird.


Zu Zustandsautomaten, Lexern, Parsern, Compilern, Grammatiken gibt es tonnenweise Literatur. Ist sozusagen die Königsdisziplin der Informatik. Lediglich für die einzelnen Tools gibt es weniger Literatur, was einfach nur daran liegt, dass sie sich alle ähnlich sind. Das Konzept ist immer das gleiche und warum sollte man das gleiche 1000 mal wiederkäuen?
Oder was denkst du wie man auf das Akronym ANother Tool for Language Recognition kam?


----------



## starfox (6. Sep 2008)

Andrey hat gesagt.:
			
		

> Ein ziemlich dreckiger Trick wäre natürlich, die beiden formeln zu parsen (also eingabe sowie das erwartete ergebnis) und die an paar hundert stellen auszuwerten. Wenn man dann keinen großen numerischen Unterschied feststellt, kann man mit einer gewissen Wahrscheinlichkeit annehmen, dass derjenige, der das eingetippt hat, in etwa wusste was er da tut, und ein richtiges ergebnis geliefert hat. Das kann allerdings auch ziemlich schief gehen, etwa wenn sich jemand den scherz erlaubt, statt zB "e^pi*x"  sowas wie "e^pi*x+0.0000000001" einzutippen, und dann trotzdem gesagt bekommt "ihre lösung ist richtig"



Jep, auf so eine Idee bin ich auch schon gekommen, find ich eigentlich ganz i.O.!

Aber wie gestalte ich ein Applet für Aufgaben à la Terme vereinfachen/? Beispiel : Vereinfache den Term "(a^2)^0,5". (lsg. wäre "a"). Das geht dann aber einfach nach dem Prinzip Passwortabfrage oder?


----------



## 0x7F800000 (6. Sep 2008)

naja, wenn all deine ergebnisse aussehen werden wie "a" "b²" oder "-c³" dann brauchst du dafür echt keine Parser oder ähnliches... Allerdings weiß ich dann nicht, was denn bitte so ein Applet überhaupt bringen soll. Mach dann stattdessen einen multiple-choise test (aber dann bitte ohne applets, shockwave-player oder irgendwelchen sonstigen abgefahrenen plugins) Wesentlich einfacher zu "implementieren" und wesentlich stressfreier für den benutzer.


----------

