Evaluator: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
K (LaTeX korrigiert)
 
(27 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
=== Beschreibung ===
Der Evaluator ist das Evaluierungswerkzeug, welches von JACK für Berechnungen aller Art (z.B. mathematische und chemische Berechnungen) verwendet wird. Der Evaluator wird daher sowohl für die Erzeugung von [[Variablen (JACK3)|Variablen]] genutzt, als auch um die Prüfregeln für richtige Antworten bzw. Feedbacknachrichten auszuwerten. Er beherrscht eine Reihe von Funktionen, z.B. einfache arithmetische Operationen und Funktionen auf Zeichenketten, ist jedoch auch in der Lage mit Computer Algebra Systemen zu kommunizieren und dort Auswertungen vornehmen zu lassen. Derzeit ist der Evaluator in der Lage mit den beiden externen Systemen [https://www.sagemath.org/| Sage] und [https://www.r-project.org/| R] zu kommunizieren. Der Evaluator bietet neben den oben beschriebenen Basisfunktionen einige CAS-Funktionen an, welche bestimmte festgelegte Auswertungen in den externen Systemen vornehmen. So kann beispielsweise mittels der Funktion [[isLinearlyIndependent]] geprüft werden, ob eine Menge von Vektoren linear unabhängig ist. Diese Funktion verwendet intern Sage, um eine Entscheidung zu finden. Der Evaluator meldet das Ergebnis dann an den JACK Kern zurück, welcher dieses weiter verarbeitet. Zudem können mit dem Evaluator auch Funktionen logisch miteinander verknüpft werden, also durch [[BooleanAnd|und]], [[BooleanOr|oder]] oder auch [[BooleanNot|nicht]].
Der Evaluator ist das Evaluierungswerkzeug, welches von JACK für Berechnungen aller Art (z.B. mathematische Berechnungen) verwendet wird. Der Evaluator wird daher sowohl für die Erzeugung von [[Variablen (Jack2)|Variablen]] genutzt, als auch um die Prüfregeln für richtige Antworten bzw. Feedbacknachrichten in [[Checker#InstantFillInChecker|Fill In Aufgaben]] auszuwerten. Er beherrscht eine Reihe von Funktionen, z.B. einfache arithmetische Operationen und Funktionen auf Zeichenketten, ist jedoch auch in der Lage, mit Computer Algebra Systemen zu sprechen und dort Auswertungen vornehmen zu lassen. Derzeit ist der Evaluator in der Lage, mit zwei externen Systemen zu kommunizieren. Es handelt sich dabei um die Systeme ''Sage'' und ''R''. Der Evaluator bietet neben den oben beschriebenen Basisfunktionen einige CAS-Funktionen an, welche bestimmte festgelegte Auswertungen in den externen Systemen vornehmen. So kann zum Beispiel mittels der Funktion ''isLinearlyIndependent'' geprüft werden, ob eine Menge von Vektoren linear unabhängig ist. Diese Funktion verwendet intern ''Sage'', um eine Entscheidung zu finden. Der Evaluator meldet das Ergebnis dann an den JACK Kern zurück, welcher dieses weiter verarbeitet. Zudem können mit dem Evaluator auch Funktionen logisch miteinander verknüpft werden, also durch "und", "oder" oder auch "nicht". Wird in einer Prüfregel einer [[Checker#InstantFillInChecker|Fill In Aufgabe]] im Tag <code><correctanswer></code> oder <code><feedback></code> ein <code><option></code>-Tag verwendet, so wird der Ausdruck im Attribut <code>result</code> dem Evaluator übergeben:


<syntaxhighlight lang="xml">
== Verwendung des Evaluators ==
<option result="evaluatorfunktion(...)">Feedback</option>
</syntaxhighlight>


Der Rückgabewert der verwendeten Funktion muss an dieser Stelle also zwingend ein Wahrheitswert sein. In den leeren Klammern müssen noch die Argumente der verwendeten Funktion ergänzt werden. Es können auch mehrere Funktionen folgendermaßen verknüpft werden:
=== Verwendung der Evaluator-Ausdrücke im Feedback ===
Wird in einer Aufgabe beim Feedback eine Evaluator Regel angegeben, dann wird der Ausdruck dem Evaluator übergeben:
[[File:Evaluator-Regel-eine-Funktion.jpg|center|thumb|800px|Hier wird ein Fill-In Feld darauf geprüft, ob es leer ist.]]
Der Rückgabewert der verwendeten Funktion muss zwingend ein Wahrheitswert sein. Also entweder es trifft zu und die Funktion gibt '''True''' zurück oder es trifft nicht zu und die Funktion gibt '''False''' zurück. Es können auch mehrere Funktionen folgendermaßen miteinander verknüpft werden:
[[File:Evaluator-Regel.jpg|center|thumb|800px|Hier werden zwei Fill-In Felder darauf geprüft, ob sie die bestimmten Werte der beiden Variabeln x und y haben.]]


<syntaxhighlight lang="xml">
=== Logische Operatoren ===
<option result="funktion1(...)&amp;&amp;funktion2(...)">Feedback</option>
Die zwei '''&'''-Zeichen stehen für die logischen ''und''-Verknüpfung. Es gibt auch die ''oder''-Verknüpfung mit zwei senkrechten Strichen ('''||''') und die ''nicht''-Verknüpfung mit dem Ausrufezeichen ('''!''').
</syntaxhighlight>
Hier ist die Auflistung der Verknüpfung '''A && B = C''', dabei sind A, B Aussagen, die entweder ''True'' oder ''False'' sind. Daraus ergibt sich dann folgendes für '''C''':
{| class="wikitable"
! A !! B !! C
|-
| True || True || True
|-
| True || False || False
|-
| False || True || False
|-
| False || False || False
|}


Die XML-Entity "&amp;amp;" steht für das ''&''-Zeichen. Zwei ''&''-Zeichen stehen wiederum für die logische "Und"-Verknüpfung. Der Ausdruck wird folglich als wahr ausgewertet, wenn beide verwendeten Funktionen wahr zurückgeben. Die "Oder"-Verknüpfung wird durch zwei senkrechte Striche ("||") erreicht und die "Nicht"-Verknüpfung durch das Ausrufungszeichen ("!").
Bei der ''oder''-Verknüfung '''A || B = C''' ergibt sich für '''C''' folgendes:
{| class="wikitable"
! A !! B !! C
|-
| True || True || True
|-
| True || False || True
|-
| False || True || True
|-
| False || False || False
|}
 
Für die ''nicht''-Verknüpfung '''!A = B''' ergibt sich für '''B''' folgendes:
{| class="wikitable"
! A !! B
|-
| True || False
|-
| False || True
|}


=== Variablen erstellen ===
=== Variablen erstellen ===
Der Evaluator kann beim Erzeugen aufgabenbezogener [[Variablen (Jack2)|Variablen]] innerhalb der [[ExerciseChain]] genutzt werden. Innerhalb des value-Attributs des <option>-Tags lassen sich Funktionen des Evaluators nutzen, um Aufgaben mit variablen Werten zu erstellen.
{{Hinweis|Siehe auch [[Variablen (JACK3)|nähere Informationen zu Variablen]].}}
 
Der Evaluator kann [[Variablen (JACK3)|Variablen]], die innerhalb einer Aufgabe definiert wurden, nutzen.
<syntaxhighlight lang="xml">
<variables>
<option name="a" value="5"/>
<option name="b" value="2"/>
<option name="c" value="[var=a]*[var=b]"/>
</variables>
</syntaxhighlight>


In diesem Beispiel werden die beiden Variablen ''a'' und ''b'' mit den Werten ''5'' bzw. ''2'' erstellt. Außerdem wird eine dritte Variable ''c'' erstellt, die das Produkt der beiden vorherigen Variablen bildet.
[[File:Variablen-erstellen.jpg|center|thumbs|800px]]


Neben den mathematischen Basisoperationen enthält der Evaluator diverse eigen-implementierte Funktionen, die teilweise auf externe Computer-Algebra-Systeme (Sage, R) zugreifen. Beim Benutzen einer solchen CAS-Funktion kann mittels des Attributs ''cas'' und den Werten ''Sage'', ''R'' explizit angegeben werden, welches CAS verwendet werden soll.
In diesem Beispiel werden die beiden Variablen ''a'' und ''b'' mit den Werten ''5'' bzw. ''2'' erstellt. Außerdem wird eine dritte Variable ''c'' erstellt, die das Produkt der beiden vorherigen Variablen bildet. Neben den mathematischen Basisoperationen enthält der Evaluator diverse Funktionen (s.u.), die teilweise auf externe Computer-Algebra-Systeme (Sage, R) zugreifen. Beim Benutzen einer solchen CAS-Funktion kann mittels [[evaluateInSage|evaluateInSage()]] oder [[evaluateInR|evaluateInR()]] das entsprechende CAS verwendet werden.


<syntaxhighlight lang="xml">
[[File:Variable-mit-Sage.jpg|center|thumbs|800px]]
<option name="b" value="factorial([var=a])" cas="R" />
</syntaxhighlight>


In diesem Fall enthält die Variable ''b'' die Fakultät der Zahl, die in der Variablen ''a'' enthalten ist, berechnet mit Hilfe des CAS R.
In diesem Fall enthält die Variable ''b'' die Fakultät der Zahl, die in der Variablen ''a'' enthalten ist, berechnet mit Hilfe des CAS Sage.
 
=== Ergebnisauswertung ===
Der Evaluator wird ebenfalls bei der Auswertung von Aufgaben verwendet, konkreter bei dem result-Attribut innerhalb des <option>-Tags.
<syntaxhighlight lang="xml">
<correctanswer>
<option result="[pos=1]==25*2"/>
<message>Richtig! Das Ergebnis ist 50.</message>
</correctanswer>
</syntaxhighlight>
In diesem Beispiel wird überprüft, ob in dem ersten [[Checker#InstantFillInChecker|Fill In]]-Feld der Aufgabe der Wert 50 steht.
 
Hierbei versucht der Evaluator den Wert des result-Attributs, also den in Anführungszeichen stehenden Ausdruck, zu einem Boolean auszuwerten. Für eine korrekte Funktionsweise ist es deswegen wichtig, dass der dort stehende Ausdruck auch tatsächlich zu einem booleschen Ergebnis validiert werden kann. Auf diese Weise können viele mitunter sehr unterschiedliche Lösungs-Einreichungen von Aufgaben auf ihre Richtigkeit geprüft werden, ohne jede einzelne Möglichkeit explizit angeben zu müssen. Hierbei kann man genauso wie beim Erstellen von Variablen auf diverse Funktionen des Evaluators zurückgreifen.


=== Funktionen ===
=== Funktionen ===
Der Evaluator beinhaltet viele verschiedene Funktionen, die alle in JACK für die Aufgabendarstellung benutzt werden können. Hier geben wir eine vollständige Liste aller angebotenen Funktionen mit ihrer Funktionalität.
Die Evaluatoren beinhalten viele verschiedene Funktionen, die alle in JACK für die Aufgabendarstellung benutzt werden können. Unter den hier angegebenen Links finden Sie eine vollständige Liste aller angebotenen Funktionen im entsprechenden Evaluator mit ihrer Funktionalität.


* [[:Kategorie:Math-Evaluatorfunktion|Math-Evaluatorfunktion]]
* [[:Kategorie:Math-Evaluatorfunktion|Math-Evaluatorfunktion]]
* [[:Kategorie:Chem-Evaluatorfunktion|Chem-Evaluatorfunktion]]
* [[:Kategorie:Chem-Evaluatorfunktion|Chem-Evaluatorfunktion]]
* [[:Kategorie:Konstruktoren|Konstruktoren]]
Welcher Evaluator für einen Ausdruck bzw. eine Variable benutzt wird, entscheidet das Drop-Down rechts neben dem Ausdruck.
* [[:Kategorie:Ausdruckfunktionen|Ausdruckfunktionen]]
* [[:Kategorie:Zeichenkettenfunktionen|Zeichenkettenfunktionen]]
* [[:Kategorie:Booleanfunktionen|Booleanfunktionen]]
* [[:Kategorie:Listfunktionen|Listfunktionen]]
* [[:Kategorie:Vektorfunktionen|Vektorfunktionen]]
* [[:Kategorie:Matrixfunktionen|Matrixfunktionen]]
* [[:Kategorie:Testfunktionen|Testfunktionen]]
* [[:Kategorie:Sparqlfunktionen|Sparqlfunktionen]]
* [[Migration zur Evaluator 2 Syntax (Jack2)|Best Practice für den Evaluator]]


===Hinweise===
== Neue Funktionen in JACK3 ==
* Wenn man zwei oder mehr Funktionen miteinander verknüpft fallen die Anführungszeichen weg: ''equalsExpr(evalEq('5','5'),'0')''
Für weitere Informationen siehe [[Evaluator-Änderungen von JACK2 nach JACK3]].


== Änderungen in JACK3 ==
'''Hinweis für JACK2:''' Wenn man zwei oder mehr Funktionen miteinander verknüpft fallen die Anführungszeichen weg: ''equalsExpr(evalEq('5','5'),'0')''.
'''Die folgenden Änderungen beziehen sich nur auf JACK3.'''


Evaluatorausdrücke werden immer geparsed und evaluiert.
=== Ausrechnen von Ausdrücken verhindern ===
Eckige Klammern können eingefügt werden, um das Evaluieren von Gesamt- und Teilausdrücken zu verhindern.
Evaluatorausdrücke werden immer ausgerechnet. Eckige Klammern können eingefügt werden, um das Evaluieren von Gesamt- und Teilausdrücken zu verhindern ("gestoppter Ausdruck").
Es gibt Funktionen, welche nicht innerhalb von eckigen Klammer auftauchen dürfen. Bei diesen entsteht beim parsen eine Fehler (random, getRandomFromList, chooseFromComplement, ...).
Ein Beispiel hierfür ist die Definition von Variablen für den Aufgabentext. Hat man bisher <code>x+2*x</code> als Variable angelegt, wurde der Ausdruck zu <code>3*x</code> zusammengefasst. Fügt man nun <code>[</code> und <code>]</code> ein, wird der Ausdruck nicht mehr ausgerechnet.
Einige Funktionen, evaluieren die Argumente nicht, um bspw. die Syntax zu analysieren (isIntegerNumber, isMatrix, isSum, isProduct, ...).
{| class="wikitable"
 
!Ausdruck
 
!Ergebnis (in LaTeX)
Beispiele:
!Erklärung
|-
|<code>x+3*x</code>
|\(4 \cdot x\)
|Der Ausdruck wird ausgerechnet.
|-
|<code>[x+3*x]</code>
|\( x+3 \cdot x \)
|Der Ausdruck wird nicht ausgerechnet.
|-
|<code>getFromList(0,list(x+3*x,[2*x+3*x]))</code>
|\( 4 \cdot x \)
|Alle Elemente der Liste werden ausgerechnet.
|-
|<code>getFromList(1,list(x+3*x,[2*x+3*x]))</code>
|\( 2 \cdot x + 3 \cdot x \)
|Die Elemente der Liste werden nicht ausgerechnet, sondern sind exakt wie eingegeben.
|}
Die Variablen können allerdings trotzdem zur Bewertung der Aufgabe verwendet werden. Sobald ein "gestoppter" Ausdruck (von <code>[</code> und <code>]</code> umschlossen) in einer Funktion verwendet wird, wird diese ausgerechnet. Dies bedeutet, dass ein "gestoppter" Ausdruck nur solange "gestoppt" ist, wie keine Funktion den Wert dieses Ausdrucks verwendet.


'''Beispiele''':
* <code>3+[x+x]</code> → \(2\cdot x + 3\). Da <code>[x+x]</code> Teil einer Funktion (Summe) ist, wird der Ausdruck ausgerechnet.
*<code>[3+x+x]</code> →  \(3+x+x\). Hier ist der Ausdruck selbst eine Summe. Da er hier kein Parameter einer weiteren Funktion ist, wird er nicht ausgerechnet.
*<code>varA := [3+x+x]</code> und <code>varB := [var=varA]+3</code> → \(2 \cdot x + 6\). Hier ist <code>[3+x+x]</code> wieder Teil einer Summe und wird daher ausgerechnet.
*<code>varA := [3+x+x]</code> und <code>varB := [[var=varA]+3]</code> →  \(3+x+x+3\). Hier ist <code>[3+x+x]</code> zwar auch Teil einer Summe; da diese aber auch mit <code>[</code> und <code>]</code> umschlossen ist, wird der Ausdruck nicht ausgerechnet.
*<code>getFromList([1+1], list(1,2,3))</code> → \(3\). Hier ist <code>[1+1]</code> Teil einer Funktion, die den genauen Wert benötigt. Daher wird <code>[1+1]</code> berechnet.
Einige Funktionen, evaluieren die Argumente nicht, um bspw. die Syntax zu analysieren (z.B. [[isIntegerNumber]], [[isMatrix]], [[isSum]], [[isProduct]], ...).
{| class="wikitable"
{| class="wikitable"
|+Weitere Beispiele und Vergleiche
|-
|-
! Variablenname!! Ausdruck!! Wert
! Variablenname!! Ausdruck!! Wert
Zeile 85: Zeile 112:
| [var=B]|| [1+1]|| 1+1
| [var=B]|| [1+1]|| 1+1
|-
|-
| || ||  
| || ||
|-
|-
| [var=C]|| 1+[var=A]||3
| [var=C]|| 1+[var=A]||3
Zeile 95: Zeile 122:
| [var=F]||[1+[var=B]]|| 1+1+1
| [var=F]||[1+[var=B]]|| 1+1+1
|-
|-
| || ||  
| || ||
|-
|-
| [var=J]|| getFromList(1,list(2,3,4))|| 3
| [var=J]|| getFromList(1,list(2,3,4))|| 3
Zeile 103: Zeile 130:
| [var=L]|| getFromList(1,list(2,[var=A],4))|| 2
| [var=L]|| getFromList(1,list(2,[var=A],4))|| 2
|-
|-
| [var=M]|| getFromList(1,list(2,[var=B],4))|| 1+1
| [var=M]|| getFromList(1,list(2,<nowiki>[[var=B]]</nowiki>,4))|| 1+1 (zu beachten ist hier, dass zum "Stoppen" von B doppelte Klammern erforderlich sind)
|-
|-
| [var=N] || getFromList([1+1],list(2,3,4))|| 4
| [var=N] || getFromList([1+1],list(2,3,4))|| 4
Zeile 111: Zeile 138:
| [var=P] || getFromList([var=B],list(2,3,4)) || 4
| [var=P] || getFromList([var=B],list(2,3,4)) || 4
|-
|-
| [var=Q] || [getFromList(1,list(2,3,4))]||  
|[var=P2]
getFromList(1,list(2,3,4))
|getFromList(<nowiki>[[var=B]]</nowiki>,list(2,3,4))
|4, B wird hier zwangsläufig ausgerechnet.
|-
| [var=Q] || [getFromList(1,list(2,3,4))]||
3 (die Listenfunktion selbst kann nicht gestoppt werden)
|-
|-
| || ||
|[var=Q2]
|[getFromList(1, list(1+1,2+2,3+3))]
|2+2 (die einzelnen Elemente werden nicht ausgerechnet)
|-
|-
| [var=R]|| [random()]|| EXCEPTION
| || ||
|-
| [var=R]|| [random()]|| Beispiel: 0.547 (random() selbst kann nicht gestoppt werden)
|-
|[var=R2]
|[random()+random()]
|Beispiel: 0.871+0.219 (die Addition wird beibehalten)
|-
|-
| [var=S] || [getRandomFromList(list(1,2,3,4,5))]
| [var=S] || [getRandomFromList(list(1,2,3,4,5))]
|| EXCEPTION
|| Beispiel: 3
|-
|[var=S2]
|[getRandomFromList(list(1+1,2+2,3+3))]
|Beispiel: 1+1 (die einzelnen Elemente werden nicht ausgerechnet)
|-
|-
| [var=T] || isIntegerNumber([1+1])|| false
| [var=T] || isIntegerNumber([1+1])|| false
Zeile 128: Zeile 171:
|-
|-
| [var=W] || isIntegerNumber([var=B])|| false
| [var=W] || isIntegerNumber([var=B])|| false
|-
|
|sqrt(9)
|3
|-
|
|[sqrt(9)]
|\( \sqrt{9} \)
|-
|
|sqrt(1 + 3)
|2
|-
|
|[sqrt(1  +  3)]
|\( \sqrt{1+3} \)
|-
|
|sqrt([1 + 3])
|2, da der Ausdruck in eckigen Klammern innerhalb einer Funktion auftaucht
|}
|}
[[Category:Evaluator]]
[[Kategorie:Evaluator]]
[[Kategorie:Benutzerhandbuch]]
[[Kategorie:Hauptseiten]]

Aktuelle Version vom 17. September 2024, 11:30 Uhr

Der Evaluator ist das Evaluierungswerkzeug, welches von JACK für Berechnungen aller Art (z.B. mathematische und chemische Berechnungen) verwendet wird. Der Evaluator wird daher sowohl für die Erzeugung von Variablen genutzt, als auch um die Prüfregeln für richtige Antworten bzw. Feedbacknachrichten auszuwerten. Er beherrscht eine Reihe von Funktionen, z.B. einfache arithmetische Operationen und Funktionen auf Zeichenketten, ist jedoch auch in der Lage mit Computer Algebra Systemen zu kommunizieren und dort Auswertungen vornehmen zu lassen. Derzeit ist der Evaluator in der Lage mit den beiden externen Systemen Sage und R zu kommunizieren. Der Evaluator bietet neben den oben beschriebenen Basisfunktionen einige CAS-Funktionen an, welche bestimmte festgelegte Auswertungen in den externen Systemen vornehmen. So kann beispielsweise mittels der Funktion isLinearlyIndependent geprüft werden, ob eine Menge von Vektoren linear unabhängig ist. Diese Funktion verwendet intern Sage, um eine Entscheidung zu finden. Der Evaluator meldet das Ergebnis dann an den JACK Kern zurück, welcher dieses weiter verarbeitet. Zudem können mit dem Evaluator auch Funktionen logisch miteinander verknüpft werden, also durch und, oder oder auch nicht.

Verwendung des Evaluators

Verwendung der Evaluator-Ausdrücke im Feedback

Wird in einer Aufgabe beim Feedback eine Evaluator Regel angegeben, dann wird der Ausdruck dem Evaluator übergeben:

Hier wird ein Fill-In Feld darauf geprüft, ob es leer ist.

Der Rückgabewert der verwendeten Funktion muss zwingend ein Wahrheitswert sein. Also entweder es trifft zu und die Funktion gibt True zurück oder es trifft nicht zu und die Funktion gibt False zurück. Es können auch mehrere Funktionen folgendermaßen miteinander verknüpft werden:

Hier werden zwei Fill-In Felder darauf geprüft, ob sie die bestimmten Werte der beiden Variabeln x und y haben.

Logische Operatoren

Die zwei &-Zeichen stehen für die logischen und-Verknüpfung. Es gibt auch die oder-Verknüpfung mit zwei senkrechten Strichen (||) und die nicht-Verknüpfung mit dem Ausrufezeichen (!). Hier ist die Auflistung der Verknüpfung A && B = C, dabei sind A, B Aussagen, die entweder True oder False sind. Daraus ergibt sich dann folgendes für C:

A B C
True True True
True False False
False True False
False False False

Bei der oder-Verknüfung A || B = C ergibt sich für C folgendes:

A B C
True True True
True False True
False True True
False False False

Für die nicht-Verknüpfung !A = B ergibt sich für B folgendes:

A B
True False
False True

Variablen erstellen

Hinweis: Siehe auch nähere Informationen zu Variablen.

Der Evaluator kann Variablen, die innerhalb einer Aufgabe definiert wurden, nutzen.

thumbs

In diesem Beispiel werden die beiden Variablen a und b mit den Werten 5 bzw. 2 erstellt. Außerdem wird eine dritte Variable c erstellt, die das Produkt der beiden vorherigen Variablen bildet. Neben den mathematischen Basisoperationen enthält der Evaluator diverse Funktionen (s.u.), die teilweise auf externe Computer-Algebra-Systeme (Sage, R) zugreifen. Beim Benutzen einer solchen CAS-Funktion kann mittels evaluateInSage() oder evaluateInR() das entsprechende CAS verwendet werden.

thumbs

In diesem Fall enthält die Variable b die Fakultät der Zahl, die in der Variablen a enthalten ist, berechnet mit Hilfe des CAS Sage.

Funktionen

Die Evaluatoren beinhalten viele verschiedene Funktionen, die alle in JACK für die Aufgabendarstellung benutzt werden können. Unter den hier angegebenen Links finden Sie eine vollständige Liste aller angebotenen Funktionen im entsprechenden Evaluator mit ihrer Funktionalität.

Welcher Evaluator für einen Ausdruck bzw. eine Variable benutzt wird, entscheidet das Drop-Down rechts neben dem Ausdruck.

Neue Funktionen in JACK3

Für weitere Informationen siehe Evaluator-Änderungen von JACK2 nach JACK3.

Hinweis für JACK2: Wenn man zwei oder mehr Funktionen miteinander verknüpft fallen die Anführungszeichen weg: equalsExpr(evalEq('5','5'),'0').

Ausrechnen von Ausdrücken verhindern

Evaluatorausdrücke werden immer ausgerechnet. Eckige Klammern können eingefügt werden, um das Evaluieren von Gesamt- und Teilausdrücken zu verhindern ("gestoppter Ausdruck"). Ein Beispiel hierfür ist die Definition von Variablen für den Aufgabentext. Hat man bisher x+2*x als Variable angelegt, wurde der Ausdruck zu 3*x zusammengefasst. Fügt man nun [ und ] ein, wird der Ausdruck nicht mehr ausgerechnet.

Ausdruck Ergebnis (in LaTeX) Erklärung
x+3*x \(4 \cdot x\) Der Ausdruck wird ausgerechnet.
[x+3*x] \( x+3 \cdot x \) Der Ausdruck wird nicht ausgerechnet.
getFromList(0,list(x+3*x,[2*x+3*x])) \( 4 \cdot x \) Alle Elemente der Liste werden ausgerechnet.
getFromList(1,list(x+3*x,[2*x+3*x])) \( 2 \cdot x + 3 \cdot x \) Die Elemente der Liste werden nicht ausgerechnet, sondern sind exakt wie eingegeben.

Die Variablen können allerdings trotzdem zur Bewertung der Aufgabe verwendet werden. Sobald ein "gestoppter" Ausdruck (von [ und ] umschlossen) in einer Funktion verwendet wird, wird diese ausgerechnet. Dies bedeutet, dass ein "gestoppter" Ausdruck nur solange "gestoppt" ist, wie keine Funktion den Wert dieses Ausdrucks verwendet.

Beispiele:

  • 3+[x+x] → \(2\cdot x + 3\). Da [x+x] Teil einer Funktion (Summe) ist, wird der Ausdruck ausgerechnet.
  • [3+x+x] → \(3+x+x\). Hier ist der Ausdruck selbst eine Summe. Da er hier kein Parameter einer weiteren Funktion ist, wird er nicht ausgerechnet.
  • varA := [3+x+x] und varB := [var=varA]+3 → \(2 \cdot x + 6\). Hier ist [3+x+x] wieder Teil einer Summe und wird daher ausgerechnet.
  • varA := [3+x+x] und varB := [[var=varA]+3] → \(3+x+x+3\). Hier ist [3+x+x] zwar auch Teil einer Summe; da diese aber auch mit [ und ] umschlossen ist, wird der Ausdruck nicht ausgerechnet.
  • getFromList([1+1], list(1,2,3)) → \(3\). Hier ist [1+1] Teil einer Funktion, die den genauen Wert benötigt. Daher wird [1+1] berechnet.

Einige Funktionen, evaluieren die Argumente nicht, um bspw. die Syntax zu analysieren (z.B. isIntegerNumber, isMatrix, isSum, isProduct, ...).

Weitere Beispiele und Vergleiche
Variablenname Ausdruck Wert
[var=A] 1+1 2
[var=B] [1+1] 1+1
[var=C] 1+[var=A] 3
[var=D] 1+[var=B] 3
[var=E] [1+[var=A]] 1+2
[var=F] [1+[var=B]] 1+1+1
[var=J] getFromList(1,list(2,3,4)) 3
[var=K] getFromList(1,list(2,[2+5],4)) 2+5
[var=L] getFromList(1,list(2,[var=A],4)) 2
[var=M] getFromList(1,list(2,[[var=B]],4)) 1+1 (zu beachten ist hier, dass zum "Stoppen" von B doppelte Klammern erforderlich sind)
[var=N] getFromList([1+1],list(2,3,4)) 4
[var=O] getFromList([var=A],list(2,3,4)) 4
[var=P] getFromList([var=B],list(2,3,4)) 4
[var=P2] getFromList([[var=B]],list(2,3,4)) 4, B wird hier zwangsläufig ausgerechnet.
[var=Q] [getFromList(1,list(2,3,4))]

3 (die Listenfunktion selbst kann nicht gestoppt werden)

[var=Q2] [getFromList(1, list(1+1,2+2,3+3))] 2+2 (die einzelnen Elemente werden nicht ausgerechnet)
[var=R] [random()] Beispiel: 0.547 (random() selbst kann nicht gestoppt werden)
[var=R2] [random()+random()] Beispiel: 0.871+0.219 (die Addition wird beibehalten)
[var=S] [getRandomFromList(list(1,2,3,4,5))] Beispiel: 3
[var=S2] [getRandomFromList(list(1+1,2+2,3+3))] Beispiel: 1+1 (die einzelnen Elemente werden nicht ausgerechnet)
[var=T] isIntegerNumber([1+1]) false
[var=U] isIntegerNumber(1+1) false
[var=V] isIntegerNumber([var=A]) true
[var=W] isIntegerNumber([var=B]) false
sqrt(9) 3
[sqrt(9)] \( \sqrt{9} \)
sqrt(1 + 3) 2
[sqrt(1 + 3)] \( \sqrt{1+3} \)
sqrt([1 + 3]) 2, da der Ausdruck in eckigen Klammern innerhalb einer Funktion auftaucht