JACK Wiki - Benutzerbeiträge [de]

IsRealNumber

2022-01-31T15:07:34Z

Spobel:

==Zugehörige Evaluatoren==
*'''MathEvaluator'''
=== Beschreibung ===
Die Funktion ''isRealNumber'' prüft, ob es sich bei einem gegebenen [[Objekt]] um eine reelle Zahl handelt. Die Funktion gibt einen Boolean zurück. Alias: "isNumber"

=== Syntax ===
isRealNumber(Objekt objekt)

=== Parameter ===
* '''objekt''' - das zu überprüfende Objekt

=== Return Value ===
* Gibt einen [[Boolean]] zurück

=== Beispiele ===
==== Standardfälle ====
isRealNumber(15.3) --> returns true

isRealNumber('zahl') --> returns false

==== Benutzung von Variablen ====
isRealNumber([pos=1])

isRealNumber([var=a])

=== Hinweise ===
Die Überprüfung mit Textfeldern funktioniert nur, wenn man den [[:Formeleditor]] verwendet.

Gibt man keinen Editor an, wird für ein Textfeld (<code>[pos=1] usw.</code>) ein OpenMath String zurückgegeben. Dadurch gibt <code>isRealNumber([pos=1])</code> sowie <code> isRealNumber('[pos=1]')</code> immer false zurück.
Um ein richtiges Ergebnis zu erlangen, muss [[Matches#Benutzung von Textfeldern|Matches]] genutzt werden.
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Testfunktionen]]

IsNumber

2022-01-31T15:06:56Z

Spobel: Weiterleitung nach IsRealNumber erstellt

#REDIRECT [[IsRealNumber]]

GetParameter

2022-01-31T14:36:39Z

Spobel: /* Standardfälle */

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

=== Beschreibung ===

Die Funktion ''getParameter'' arbeitet auf komplexen Objekten wie bspw. Summen oder Produktzeichen.
Die Rückgabe ist das Objekt an der jeweiligen Stelle im umgebenden komplexen Objekt.

=== Syntax ===
getParameter([[Ganzzahl]] position, [[Objekt]] objekt)

=== Parameter ===
* '''position''' die Stelle des inneren Objekts
* '''objekt''' das komplexe Objekt aus dem ein Parameter gezogen werden soll

=== Return Value ===
* Gibt eine Objekt zurück

=== Beispiele ===
==== Standardfälle ====
getParameter(0, 1+2) --> returns 1

getParameter(0, (1-2)+(3-4)) --> returns '1-2'

getParameter(1, (1-2)+(3-4)) --> returns '3-4'

getParameter(0, sum(integerInterval(1, 100), lambda(n+1, n))) --> returns integerInterval(1, 100)

getParameter(1, sum(integerInterval(1, 100), lambda(n+1, n))) --> returns lambda(n+1, n)

==== Benutzung von Variablen ====
[input=field1] := sum(integerInterval(1, 100), lambda(n+1, n))

[var=intervalIndex] := 0

[var=functionIndex] := 1

getParameter([var=intervalIndex], [input=field1]) --> returns integerInterval(1, 100)

getParameter([var=intervalIndex], [input=field1]) --> returns lambda(n+1, n)

[[Kategorie:Math-Evaluatorfunktion]][[Category:JACK3]]

GetParameter

2022-01-31T14:36:27Z

Spobel: /* Benutzung von Variablen */

GetParameter

2022-01-31T14:36:14Z

Spobel: /* Standardfälle */

Product

2022-01-31T14:27:33Z

Spobel:

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''product'' erzeugt das math. Produktzeichen.

===Syntax===
product([[IntegerInterval]] interval, [[LambdaFunktion]] lambda)

===Parameter===
* '''interval''' - das [[IntegerInterval]], welches die Laufvariable der Summe bestimmt
* '''lambda''' - eine Lambda Funktion, welche die Luafvariable als Bindungsvariable und den Ausdruck enthält

===Return Value===
* Gibt das Produktzeichen zurück

===Beispiele===
product(integerInterval(0,10), lambda(x+1, x)) --> returns <math>\prod_{x=0}^{10} {x+1}</math>

product(integerInterval(-10,0), lambda(n+1+a, n)) --> returns <math>\prod_{n=-10}^{0} {n+1+a}</math>

===Vollständiges Testen einer Produkt-Eingabe===

[input=produkt] := <math>\prod_{x=0}^{10} {x+1}</math>

getParameter(0, [input=produkt]) --> integerInterval(0, 10)
isIntegerInterval( getParameter(0, [input=produkt]) ) --> TRUE
getParameter(0, getParameter(0, [input=produkt])) --> 0 //startIndex
getParameter(1, getParameter(0, [input=produkt])) --> 10 //endIndex

getParameter(1, [input=produkt]) --> lambda(x+1, x)
isLambdaFunction(getParameter(1, [input=produkt])) --> TRUE
lambdaHasBindingVars(getParameter(1, [input=produkt]), x) --> TRUE
lambdaExprEqualsExpr(getParameter(1, [input=produkt]), x+1) --> TRUE

approx([input=produkt]) --> 39916800
[input=produkt]==39916800 --> TRUE

[[Kategorie:Math-Evaluatorfunktion]]

IsProduct

2022-01-31T14:24:30Z

Spobel: Die Seite wurde neu angelegt: „{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}} ==Zugehörige Evaluatoren== *'''MathEvaluator''' ===Beschreibun…“

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''isProduct'' gibt nur dann wahr(true) zurück, wenn der angegebene Parameter eine [[Product|Produkt]] ist.

===Syntax===
isProduct([[Objekt]] objekt)

===Parameter===
* '''objekt''' - das [[Objekt]], welches auf [[Product]] überprüft werden soll

===Return Value===
* Gibt True oder False zurück.

===Beispiele===
isProduct(product(integerInterval(0,10), lambda(x+1,x))) --> returns true

isProduct(list(2,3)) --> returns false

[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Testfunktionen]]

Sum

2022-01-28T10:51:47Z

Spobel:

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''sum'' erzeugt das math. Summenzeichen.

===Syntax===
sum([[IntegerInterval]] interval, [[LambdaFunktion]] lambda)

===Parameter===
* '''interval''' - das [[IntegerInterval]], welches die Laufvariable der Summe bestimmt
* '''lambda''' - eine Lambda Funktion, welche die Luafvariable als Bindungsvariable und den Ausdruck enthält

===Return Value===
* Gibt das Summenzeichen zurück

===Beispiele===
sum(integerInterval(0,10), lambda(x+1, x)) --> returns <math>\sum_{x=0}^{10} {x+1}</math>

sum(integerInterval(-10,0), lambda(n+1+a, n)) --> returns <math>\sum_{n=-10}^{0} {n+1+a}</math>

===Vollständiges Testen einer Summen-Eingabe===

[input=summe] := <math>\sum_{x=0}^{10} {x+1}</math>

getParameter(0, [input=summe]) --> integerInterval(0, 10)
isIntegerInterval( getParameter(0, [input=summe]) ) --> TRUE
getParameter(0, getParameter(0, [input=summe])) --> 0 //startIndex
getParameter(1, getParameter(0, [input=summe])) --> 10 //endIndex

getParameter(1, [input=summe]) --> lambda(x+1, x)
isLambdaFunction(getParameter(1, [input=summe])) --> TRUE
lambdaHasBindingVars(getParameter(1, [input=summe]), x) --> TRUE
lambdaExprEqualsExpr(getParameter(1, [input=summe]), x+1) --> TRUE

approx([input=summe]) --> 66
[input=summe]==66 --> TRUE

[[Kategorie:Math-Evaluatorfunktion]]

LambdaHasBindingVariables

2022-01-28T10:42:17Z

Spobel:

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''lambdaHasBindingVariables'' oder auch ''lambdaHasBindingVars'' prüft eine [[LambdaFunktion]] auf enthaltene Bindungs-Variablen.

===Syntax===
lambdaHasBindingVariables([[LambdaFunktion]] lambda, [[Zeichen]] variablen...)

===Parameter===
* '''lambda''' - die LambdaFunktion, welche die variablen enthalten soll.
* '''variablen''' - menge von Variablen die in lambda enthalten sein sollen.

===Return Value===
* Gibt True oder False zurück.

===Beispiele===
lambdaHasBindingVars(lambda(n+1, n), n) --> returns true

lambdaHasBindingVars(lambda(n+1, n), list(n)) --> returns true

lambdaHasBindingVars(lambda(n+1+a, n, a), n, a) --> returns true

lambdaHasBindingVars(lambda(n+1+a, n, a), list(n, a)) --> returns true

lambdaHasBindingVars(lambda(n+1, n, a), n, a) --> returns true

[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Testfunktionen]]

LambdaHasBindingVariables

2022-01-28T10:40:39Z

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''lambdaHasBindingVariables'' oder auch ''lambdaHasBindingVars'' prüft eine [[LambdaFunktion]] auf enthaltene Bindungs-Variablen.

===Syntax===
lambdaHasBindingVariables([[LambdaFunktion]] lambda, [[Zeichen]] variablen...)

===Parameter===
* '''lambda''' - die LambdaFunktion, welche die variablen enthalten soll.
* '''variablen''' - menge von Variablen die in lambda enthalten sein sollen.

===Return Value===
* Gibt True oder False zurück.

===Beispiele===
lambdaHasBindingVars(lambda(n+1, n), n) --> returns true

lambdaHasBindingVars(lambda(n+1+a, n, a), n, a) --> returns true

lambdaHasBindingVars(lambda(n+1, n, a), n, a) --> returns true

[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Testfunktionen]]

LambdaExpressionEqualsExpression

2022-01-28T10:22:54Z

Spobel: Die Seite wurde neu angelegt: „==Zugehörige Evaluatoren== *'''MathEvaluator''' ===Beschreibung=== Die Funktion ''lambdaExpressionEqualsExpression'' oder auch ''lambdaExprEqualsExpr'' vergle…“

==Zugehörige Evaluatoren==
*'''MathEvaluator'''
===Beschreibung===
Die Funktion ''lambdaExpressionEqualsExpression'' oder auch ''lambdaExprEqualsExpr'' vergleicht das Argument einer [[LambdaFunktion] mit einem mathematischen Ausdruck.

===Syntax===
lambdaExprEqualsExpr([[LambdaFunktion]] lambda, [[Ausdruck]] term)
lambdaExpressionEqualsExpression([[LambdaFunktion]] lambda, [[Ausdruck]] term)

===Parameter===
* '''lambda''' - die LambdaFunktion, die das zu vergleichende Argument enthält
* '''term''' - der Ausdruck, der mit dem Argument der LambdaFunktion verglichen werden soll

===Return Value===
* Gibt einen Boolean zurück, ''true'' falls die beiden Ausdrücke übereinstimmen und ''false'' falls sie nicht übereinstimmen.

===Hinweise===

Die Funktion arbeitet ähnlich zur Funktion [[EqualsExpr]].

===Beispiele===

lambdaExprEqualsExpr(lambda(x+1, x), x+1) --> returns true

lambdaExprEqualsExpr(lambda(x+1, x, a, b), x+1) --> returns true

lambdaExprEqualsExpr(lambda(x*2, x, a, b), 2*x) --> returns true

[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Ausdruckfunktionen]]

IsLambdaFunction

2022-01-28T10:14:58Z

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''isLambdaFunction'' gibt nur dann wahr(true) zurück, wenn der angegebene Parameter ein [[LambdaFunktion]] ist.

===Syntax===
isLambdaFunction([[Objekt]] objekt)

===Parameter===
* '''objekt''' - das [[Objekt]], welches auf [[LambdaFunktion]] überprüft werden soll

===Return Value===
* Gibt True oder False zurück.

===Beispiele===
isLambdaFunction(lambda(x+1, x)) --> returns true

isLambdaFunction(x+1) --> returns false

[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Testfunktionen]]

IntegerInterval

2022-01-28T10:12:06Z

Spobel:

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Funktion des Evaluators in JACK3.}}

== Zugehörige Evaluatoren ==
*'''MathEvaluator'''

=== Beschreibung ===
Die Funktion ''integerInterval'' beschreibt das Intervall von zwei integer Zahlen. Es wird nicht auf Richtigkeit überprüft.

=== Syntax ===
integerInterval([[Ganzzahl]] zahl1, [[Ganzzahl]] zahl2)

=== Parameter ===
* '''zahl1''' - untere Grenze des Intervalls
* '''zahl2''' - obere Grenze des Intervalls

=== Return Value ===
* Gibt das Intervall zurück

=== Beispiele ===
integerInterval(2, 5)

=== Hinweise ===
* Die erste Zahl sollte kleiner als die zweite Zahl sein.

[[Kategorie:Math-Evaluatorfunktion]][[Category:JACK3]]

IntegerInterval

2022-01-28T10:12:00Z

Spobel:

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Funktion des Evaluators in JACK3.}}

== Zugehörige Evaluatoren ==
*'''MathEvaluator'''

=== Beschreibung ===
Die Funktion ''integerInterval'' beschreibt das Intervall von zwei integer Zahlen. Es wird nicht auf Richtigkeit überprüft.

=== Syntax ===
integerInterval([[Ganzzahl]] zahl1, [[Ganzzahl]] zahl2)

=== Parameter ===
* '''zahl1''' - untere Grenze des Intervalls
* '''zahl2''' - obere Grenze des Intervalls

=== Return Value ===
* Gibt das Intervall zurück

=== Beispiele ===
integerInterval(2,c5)

=== Hinweise ===
* Die erste Zahl sollte kleiner als die zweite Zahl sein.

[[Kategorie:Math-Evaluatorfunktion]][[Category:JACK3]]

IsIntegerInterval

2022-01-28T10:11:46Z

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''isIntegerInterval'' gibt nur dann wahr(true) zurück, wenn der angegebene Parameter ein [[IntegerInterval]] ist.

===Syntax===
isIntegerInterval([[Objekt]] objekt)

===Parameter===
* '''objekt''' - das [[Objekt]], welches auf [[IntegerInterval]] überprüft werden soll

===Return Value===
* Gibt True oder False zurück.

===Beispiele===
isIntegerInterval(integerInterval(0, 10)) --> returns true

isIntegerInterval(integerInterval(1, 2.012)) --> returns false

[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Testfunktionen]]

LambdaFunktion

2022-01-28T10:09:40Z

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''lambda'' erzeugt eine Lambda Funktion mit Bindungsvariablen.

Diese Funktion wird bspw. für das Summen- ([[Sum]]) oder Produktzeichen ([[Product]]) benötigt, um die Laufvariable des Arguments zu binden.

===Syntax===
lambda([[Ausdruck]] argument, [[Zeichen]] bindungsvariablen...)

===Parameter===
* '''argument''' - der Term, welcher Variablen enthält, die gebunden werden sollen
* '''bindungsvariablen...''' - menge von Variablen, die gebunden werden sollen

===Return Value===
* Gibt die LambdaFunktion zurück

===Beispiele===
lambda(x+1, x) --> returns <math>\lambda{x}.{x+1}</math>

lambda(a^2+2*a*b+b^2, a, b) --> returns <math>\lambda{a},\lambda{b}.{{a}^{2} + {2} \cdot {a} \cdot {b}+{b}^{2}}</math>

[[Kategorie:Math-Evaluatorfunktion]]

Product

2022-01-28T09:58:47Z

Sum

2022-01-28T09:57:28Z

IsSum

2022-01-28T09:50:39Z

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion des JACK3-Systems.}}

==Zugehörige Evaluatoren==
*'''MathEvaluator'''

===Beschreibung===
Die Funktion ''isSum'' gibt nur dann wahr(true) zurück, wenn der angegebene Parameter eine [[Sum]] ist.

===Syntax===
isSum([[Objekt]] objekt)

===Parameter===
* '''objekt''' - das [[Objekt]], welches auf [[Sum]] überprüft werden soll

===Return Value===
* Gibt True oder False zurück.

===Beispiele===
isSum(sum(integerInterval(0,10), lambda(x+1,x))) --> returns true

isSum(list(2,3)) --> returns false

[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Testfunktionen]]

GetParameter

2022-01-28T08:43:36Z

Equal

2021-01-27T07:53:40Z

Spobel: /* Beschreibung */

==Zugehörige Evaluatoren==
*'''MathEvaluator'''
===Beschreibung===
Die Funktionen ''equal'' vergleicht zwei 'einfache' math. Ausdrücke auf Gleichheit miteinander. Wenn die beiden Ausdrücke übereinstimmen gibt die Funktion ''true'' zurück, ansonsten ''false''.

===Syntax===
a == b
equal(a,b)

===Parameter===
* '''a''' - [[Zeichenkette]] oder [[Gleitkommazahl]]
* '''b''' - [[Zeichenkette]] oder [[Gleitkommazahl]]

===Return Value===
* Gibt einen Boolean zurück.

===Beispiele===
2+3 == 5 --> returns true

equal(4+3,7) --> returns true

===Hinweise===
* Die Funktion ''equal'' kann auch mit einfachen mathematischen Operationen umgehen, wie z.B. 2+3.

[[Kategorie:Math-Evaluatorfunktion]]

Equal

2021-01-27T07:53:21Z

Spobel: /* Beispiele */

==Zugehörige Evaluatoren==
*'''MathEvaluator'''
===Beschreibung===
Die Funktionen ''equal'' vergleicht zwei math. Ausdrücke auf Gleichheit miteinander. Wenn die beiden Ausdrücke übereinstimmen gibt die Funktion ''true'' zurück, ansonsten ''false''.

===Syntax===
a == b
equal(a,b)

===Parameter===
* '''a''' - [[Zeichenkette]] oder [[Gleitkommazahl]]
* '''b''' - [[Zeichenkette]] oder [[Gleitkommazahl]]

===Return Value===
* Gibt einen Boolean zurück.

===Beispiele===
2+3 == 5 --> returns true

equal(4+3,7) --> returns true

===Hinweise===
* Die Funktion ''equal'' kann auch mit einfachen mathematischen Operationen umgehen, wie z.B. 2+3.

[[Kategorie:Math-Evaluatorfunktion]]

Equal

2021-01-27T07:53:09Z

Spobel: /* Beschreibung */

==Zugehörige Evaluatoren==
*'''MathEvaluator'''
===Beschreibung===
Die Funktionen ''equal'' vergleicht zwei math. Ausdrücke auf Gleichheit miteinander. Wenn die beiden Ausdrücke übereinstimmen gibt die Funktion ''true'' zurück, ansonsten ''false''.

===Syntax===
a == b
equal(a,b)

===Parameter===
* '''a''' - [[Zeichenkette]] oder [[Gleitkommazahl]]
* '''b''' - [[Zeichenkette]] oder [[Gleitkommazahl]]

===Return Value===
* Gibt einen Boolean zurück.

===Beispiele===
2+3 == 5 --> returns true

equal(4+3,7) --> returns true

'world of math' == 'world of math' --> returns true

equal('JACK','jack') --> returns false

===Hinweise===
* Die Funktion ''equal'' kann auch mit einfachen mathematischen Operationen umgehen, wie z.B. 2+3.

[[Kategorie:Math-Evaluatorfunktion]]

SortLexicographicalList

2020-12-16T19:01:54Z

Spobel:

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Funktion des Evaluators in JACK3. JACK3 ist derzeit noch in Entwicklung und noch nicht für die Benutzung freigegeben.}}

==Allgemein==
Die Funktion sortiert eine Liste. Die liste darf dabei nur Terminale (String, Double oder Integer) beinhalten.

Es wird eine sortierte Liste zurückgegeben. Der Typ der Listelemente wird nicht geändert.

===Beispiele===
* <code>sortLexicographicalList(list(1, 1.0, 0, 'world', 'hello', '!')) -> list('!', 0, 1, 1.0, 'hello', 'world')</code>
* <code>sortLexicographicalList(list('abc',2,7,'test')) -> list(2,7,'abc','test')</code>

SortLexicographical

2020-12-16T19:01:33Z

Spobel: Spobel verschob die Seite SortLexicographical nach SortLexicographicalList

#WEITERLEITUNG [[SortLexicographicalList]]

SortLexicographicalList

2020-12-16T19:01:33Z

Spobel: Spobel verschob die Seite SortLexicographical nach SortLexicographicalList

{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Funktion des Evaluators in JACK3. JACK3 ist derzeit noch in Entwicklung und noch nicht für die Benutzung freigegeben.}}

==Allgemein==
Die Funktion sortiert eine Liste. Die liste darf dabei nur Terminale (String, Double oder Integer) beinhalten.

Es wird eine sortierte Liste zurückgegeben. Der Typ der Listelemente wird nicht geändert.

===Beispiele===
* <code>sortLexicographical(list(1, 1.0, 0, 'world', 'hello', '!')) -> list('!', 0, 1, 1.0, 'hello', 'world')</code>
* <code>sortLexicographical(list('abc',2,7,'test')) -> list(2,7,'abc','test')</code>

ToRadian

2020-12-16T16:18:03Z

Spobel: /* Standardfälle */

==Zugehörige Evaluatoren==
*'''MathEvaluator'''
=== Beschreibung ===

Die Funktion ''toRadian'' wandelt Grad-Werte in Radiant um. Die Funktion erwartet einen Grad-Wert und gibt den entsprechenden Radiant zurück.

=== Syntax ===
toRadian([[Gleitkommazahl]] grad)

=== Parameter ===
* '''grad''' - der umzuwandelnde Grad-Wert

=== Return Value ===
*Gibt den Grad-Wert als Radiant zurück

=== Beispiele ===
==== Standardfälle ====
toRadian(180) --> returns pi

toRadian(360) --> returns 2 * pi

==== Benutzung mit Variablen ====
toRadian([pos=1])

toRadian([var=a])

=== Hinweise ===

[[Kategorie:Math-Evaluatorfunktion]]

Evaluator-Änderungen von JACK2 nach JACK3

2020-08-11T08:42:39Z

Spobel:

{{Vorlage:Warnung|Warnung=Diese Seite ist beinhaltet alle Unterschiede zum alten Evaluator im JACK3 System. JACK3 ist derzeit noch in Entwicklung und noch nicht für die Benutzung freigegeben.}}
==Allgemein==
In JACK3 wird nun eine neue Evaluatorversion genutzt. Im folgenden werden die Änderungen/Unterschiede zur alten Version aufgezählt.

==Zeichenketten/Strings==
Zeichenketten/Strings können in der Syntax mit einfachen oder doppelten Anführungszeichen verwendet werden.

Eine Benutzung der jeweils anderen ist dann ohne Escaping <code>\" \'</code> möglich.

'''Achtung! Das Escaping wird nicht vom Evaluator aufgelöst! '''

Bsp.:

* <code>"Dies ist ein 'Beispiel'."</code>
* <code>'Dies ist ein anderes "Beispiel".'</code>
* <code>"Dies ist ein drittes \"Beispiel\"."</code>
* <code>'Dies ist ein letztes \'Beispiel\'.'</code>

Zeichenketten werden nicht mehr vom Evaluator zerlegt und interpretiert.

Das heißt, die Ersetzung von Variablen mit ihren zugehörigen Werten in Zeichenketten geschieht nicht mehr automatisch.

Bsp.: In <code>"Die Ersetzung von Variablen [var=text1] wird nicht mehr automatisch vorgenommen."</code> wird <code>[var=text1]</code> nicht ersetzt.

Mit der Funktion <code>concat()</code> können Variablenwerte aber mit einer oder mehreren Zeichenketten verknüpft werden:

Bsp.: In <code> concat("Die Ersetzung von Variablen ", [var=text1], " kann so vorgenommen werden.") </code> wird <code>[var=text1]</code> durch ihren Wert ersetzt.

Nutzt man in <code>equalsExpr()</code> Anführungszeichen, wird alles in den Anführungszeichen als Text erkannt. Lässt man die Anführungszeichen weg, wird alles als mathematischer Ausdruck erkannt.

Bsp:
* <code>equalsExpr('x^2+3', [input=gleichung])</code> -> <code>x^2+3</code> wird als Text, nicht als mathematischer Ausdruck erkannt.
* <code>equalsExpr(x^2+3, [input=gleichung])</code> -> <code>x^2+3</code> wird als mathematischer Ausdruck erkannt.

==Neue Funktionalität==
Es gibt nun eine Möglichkeit Ausdrücke zu definieren, welche nicht vom Evaluator ausgerechnet werden sollen.

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.

Bsp.:

* <code>x+3*x</code> -> LaTeX: <code>$4 \cdot x$</code>. Hier wird der Ausdruck ausgerechnet.
* <code>[x+3*x]</code> -> LaTeX: <code>$x+3 \cdot x$</code>. Hier wird der Ausdruck nicht ausgerechnet.
* <code>getFromList(0,list(x+3*x,[2*x+3*x]))</code> -> LaTeX: <code>$4 \cdot x$</code>. Hier wird der Ausdruck ausgerechnet.
* <code>getFromList(1,list(x+3*x,[2*x+3*x]))</code> -> LaTeX: <code>$2 \cdot x + 3 \cdot x$</code>. Hier wird der Ausdruck nicht ausgerechnet.

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.
D.h. viel mehr, dass ein "gestoppter"-Ausdruck nur solange "gestoppt" ist, wie keine Funktion den Wert dieses "gestoppten"-Ausdrucks verwendet.

Bsp.:

* <code>3+[x+x]</code> -> LaTeX: <code>$2 \cdot x + 3$</code>. Da <code> [x+x]</code> Teil der Summe ist, wird er ausgerechnet.
* <code>[3+x+x]</code> -> LaTeX: <code>$3+x+x$</code>. Hier ist der Ausdruck selbst eine Summe. Da er hier aber kein Parameter einer weiteren Funktion ist, wird er nicht ausgerechnet.
* <code>varA=[3+x+x] varB=[var=varA]+3</code> -> LaTeX: <code>$2 \cdot x + 6$</code>. Hier ist <code>[3+x+x]</code> wieder Teil einer Summe und wird daher ausgerechnet.
* <code>varA=[3+x+x] varB=[[var=varA]+3]</code> -> LaTeX: <code>$3+x+x+3$</code>. 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> -> LaTeX: <code>3</code>. Hier ist <code>[1+1]</code> Teil einer Funktion, die den genauen Wert benötigt. Daher wird <code>[1+1]</code> berechnet.

==Nicht mehr unterstützte Funktionen==
* <code>getFromSet</code>
* <code>getFromOrderedSet</code>
* <code>equalsSemiSem</code>
* <code>eval</code>
* <code>evalCplx</code>
* <code>evalEq</code>
* <code>evalPolynomial</code>
* <code>evalPolynomialCplx</code>
* <code>evalTermIn2Variables</code>
* <code>evaluateInSymja</code>
* <code>expand</code>

* <code>getFromOrderedList</code> wird durch <code>sortXList</code>, wobei <code>X</code> der Typ der Listenelemente ist (s. Neue Funktionen), und <code>getFromList</code> ersetzt. Mit <code>sortXList</code> wird die Liste sortiert und mit <code>getFromList</code> kann ein Element aus dieser Liste ausgewählt werden.

== Geänderte Funktionen ==

* <code>ifthenelse</code>
** 0 wird zu ''falsch'' ausgewertet, 1 wird zu ''richtig'' ausgewertet.
** Alle anderen Ergebnisse führen zu einem Fehler.

== evaluateInSage und evaluateInR==

Die beiden Funktionen <code>evaluateInSage</code> und <code>evaluateInR</code> werten die Eingabe direkt in einem CAS aus.

Der Inhalt der Funktionen ist '''immer''' ein String/Zeichenkette. Auch darf die Eingabe nicht verschachtelte Funktionen beinhalten. Sie wird '''nicht''' geparsed und '''nicht''' evaluiert.

Wenn eine Variable in den Funktionen genutzt werden soll, kann diese, wie zuvor, innerhalb des CAS-Strings angegeben werden.

* <code>evaluateInSage("bool(1+[var=value2]==3)")</code> ist möglich
* <s><code>evaluateInSage(concat("bool(1+", [var=value2], "==3)")</code></s> ist '''nicht''' möglich

==Neue Funktionen==
Die folgenden Funktionen erwarten als Argument eine Liste und geben eine Liste zurück.

* <code>sortDoubleList</code>
** sortiert eine Liste, die nur Doubles/Floats oder Integers beinhaltet
** Ausgabe ist eine sortierte Liste mit Doubles/Floats
* <code>sortIntegerList</code>
** sortiert eine Liste, die nur Integers beinhaltet
** Ausgabe ist eine sortierte Liste mit Integers
* <code>sortLexicographical</code>
** sortiert eine Liste, die nur Terminale beinhaltet (String/Double/Integer)
** Ausgabe ist eine sortierte Liste mit '''Strings'''
* <code>sortNumberList</code>
** sortiert eine Liste, die nur Terminale beinhaltet (Double/Integer)
** Ausgabe ist eine sortierte Liste mit '''Doubles/Floats'''
* <code>sortStringList</code>
** sortiert eine Liste, die nur Strings beinhaltet
** Ausgabe ist eine sortierte Liste mit '''Strings'''
* <code>convertToDoubleList</code>
**Elemente der Liste werden zu Double umgewandelt
* <code>convertToIntegerList</code>
** Elemente der Liste werden zu Integer umgewandelt
* <code>convertToStringList</code>
** Elemente der Liste werden zu Strings umgewandelt
* <code>removeDuplicates</code>
** Alle Duplikate werden aus der Liste gelöscht
* <code>shuffleList</code>
** Die Elemente der Liste werden geshuffelt

==Runden von Ergebnissen==

Ergebnisse werden nicht mehr vom Evaluator gerundet. Stattdessen werden die Ergebnisse genau angegeben. Bsp.: <code>exp(2)</code> wird zu <code>e^2</code> evaluiert.

Soll das Ergebnis als Zahl angegeben werden, muss eine Funktion zum Runden genutzt werden. Bsp.: <code> round(), ceil(), floor(),...</code>

==Kleine Änderungen==
* <code>constE</code>
** sowohl als <code>constE()</code> als auch als <code>conste()</code> benutzbar
* <code>constPI</code>
** sowohl als <code>constPi()</code> als auch als <code>constpi()</code> benutzbar
* <code>IEEERemainder</code>
** als <code>iEEERemainder(...)</code> benutzbar

[[Kategorie:JACK3]]

Evaluator-Änderungen von JACK2 nach JACK3

2020-05-14T14:28:53Z

Spobel:

Evaluator-Änderungen von JACK2 nach JACK3

2020-05-14T14:28:42Z

Spobel: /* Neue Funktionalität */

Evaluator-Änderungen von JACK2 nach JACK3

2020-05-14T14:23:34Z

Spobel:

Templatepaletten

2019-05-22T09:26:07Z

Spobel: /* Liste der zur Verfügung stehenden Symbole */

===Beschreibung===
Eine [[Templatepaletten|Templatepalette]] ist eine selbsterstellte Palette, die im [[Formeleditor]] in JACK eingesetzt werden kann. So können eigene Paletten erstellt werden, welche nicht im Standardrepertoire von JACK enthalten sind. Im Prinzip kann eine beliebige Palette aus den vorhandenen Eingabesymbolen des Formeleditors zusammengebaut werden und an eine Aufgabe angehängt werden. Dieses Feature gibt Lehrenden die Möglichkeit, den Lernenenden nur exakt die benötigten Eingabesymbole zur Verfügung zu stellen. Eine Palette kann nach Belieben in einzelne Tabs unterteilt werden und die Symbole können nach eigenen Wünschen in Reihen angeordnet werden. Jede Palette des Formeleditors ist ein eigens deklariertes OpenMath-Objekt, welches durch OpenMath-Symbole weiter definiert wird. Für die Schlüsselbegriffe ''palette'', ''palette_tab'' und ''palette_row'' zur Unterteilung einer Palette wurde eigens das Content Dictionnary ''editor1'' deklariert.

===Einbinden===
Im Gegensatz zu [[Standardpaletten]], welche Systemweit verfügbar sind, sind [[Templatepaletten]] nur in einer Aufgabe verfügbar. Um [[Templatepaletten]] in einer Aufgabe einzubinden, muss die selbsterstellte XML Datei der Aufgabe als WORKING_SHEET Ressource hinzugefügt werden. Zusätzlich muss in dem editor-Tag der [[Stage]] Datei der Name der Datei + Dateiendung übergeben werden. Bsp.: editor="MyPalette.xml"

===Beispiel===
Eine Templatepalettendatei ist wie folgt aufgebaut:

{| class="wikitable"
|
<code>
<OMOBJ version='2.0' xmlns='http://www.openmath.org/OpenMath'>
<OMA>
<OMS cd='editor1' name='palette'/>
<OMA>
<OMS cd='editor1' name='palette_tab'/>
<OMA>
<OMS cd='editor1' name='palette_row'/>
<OMS cd='arith1' name='plus'/>
<OMS cd='arith1' name='minus'/>
<OMS cd='arith1' name='times'/>
<OMA>
<OMS cd='transc1' name='cos'/>
<OMS cd='editor1' name='input_box'/>
</OMA>
<OMA>
<OMS cd='arith1' name='root'/>
<OMS cd='editor1' name='input_box'/>
<OMI>2</OMI>
</OMA>
</OMA>
<OMA>
<OMS cd='editor1' name='palette_row'/>
<OMS cd='relation1' name='lt'/>
<OMS cd='relation1' name='leq'/>
<OMS cd='relation1' name='eq'/>
<OMS cd='relation1' name='geq'/>
<OMS cd='relation1' name='gt'/>
</OMA>
</OMA>
</OMA>
</OMOBJ>
</code>
|[[Datei:Templatepalette1-spobel.png]]
|}

=== Liste der zur Verfügung stehenden Symbole ===
Die folgende Liste dient zur Dokumentation der zur Verfügung stehenden Symbole und ist noch nicht vollständig.
{| class="wikitable"
| '''Definition'''
| '''Symbol'''
|-
|
<OMS cd='arith1' name='plus'/>
|<math>+</math>
|-
|
<OMS cd='arith1' name='minus'/>
|<math>-</math>
|-
|
<OMS cd='arith1' name='times'/>
|<math>\cdot</math>
|-
|
<OMS cd='relation1' name='lt'/>
|<math><</math>
|-
|
<OMS cd='relation1' name='leq'/>
|<math>\leq</math>
|-
|
<OMS cd='relation1' name='gt'/>
|<math>></math>
|-
|
<OMS cd='relation1' name='geq'/>
|<math>\geq</math>
|-
|
<OMA>
<OMS cd='transc1' name='cos'/>
<OMS cd='editor1' name='input_box'/>
</OMA>
|<math>\cos( )</math>
|-
|
<OMA>
<OMS cd='arith1' name='root'/>
<OMS cd='editor1' name='input_box'/>
<OMI>2</OMI>
</OMA>
|<math>\sqrt{ }</math>
|-
|
<OMS cd='editor1' name='palette_whitespace'/>
| Platzhalter zum Formatieren
|}

=== Siehe auch ===
* [[Formeleditor]]
* [[Standardpaletten]]
[[Category:Formeleditor]]
[[category:Beispiel]]

EvaluateInR

2018-12-18T11:09:25Z

Spobel:

==Zugehörige Evaluatoren==
*'''MathEvaluator'''
===Beschreibung===
Mit der Funktion ''EvaluateInR'' ist es möglich ''R''-Befehle auszuführen. Das Argument der Funktion ist eine [[Zeichenkette]], welche in ''R'' direkt ausgeführt wird.
In der [[Zeichenkette]] können FillInvariablen (pos), sowie Aufgabenvariablen (var) auftauchen. Diese Variablen werden dann automatisch in die ''R''-Sprache übersetzt.

===Syntax===
Eine [[Variablen|Variable]] ''Test'' kann dann folgendermaßen beschrieben werden:
<syntaxhighlight lang="xml">
<option name="Test" type="Typ" cas="Evaluator" value="evaluateInR('argument')" />
</syntaxhighlight>

===Parameter===
* '''Typ''' - Entspricht dem Typen der Variable.
* '''argument''' - R-Befehl

=== Befehlsreferenz für R ===

In folgender Tabelle sind einige Beispiele, wie R verwendet werden kann. Die Variablen die damit gesetzt werden, können ebenfalls wieder in R angewandt werden oder auch für andere Zwecke im Evaluator verwendet werden.

{| class="wikitable" border="1"
|align="center"| '''argument'''
|align="center"| '''Typ'''
|align="center"| '''Beschreibung'''
|-
| list(1, 2.34)
| [[List]]
| Eine Liste mit 2 Einträgen
|-
| list(1, ...., n)
| [[List]]
| Eine Liste mit n Einträgen
|-
| c(1,2,3,4,5,6)
| [[Vektor]]
| Eine Vektor mit der Länge 6
|-
| matrix(c(1,2,3,4,5,6),2,3)
| [[Matrix]]
| Eine 2x3-Matrix mit folgenden Einträgen: [1, 3, 5; 2, 4, 6]
|}

Eine Ausführliche Dokumentation findet man hier: [https://cran.r-project.org/manuals.html]

===Beispiele===
Eine 3x3-Matrix als [[Variablen|Variable]] mit Namen A erstellt man durch den folgenden Befehl:
<syntaxhighlight lang="xml">
<option name="A" type="matrix" cas="Evaluator" value="evaluateInR('matrix(c(1,2,3,4,5,6,7,8,9),3,3)')" />
</syntaxhighlight>

In dem folgenden Beispiel wird eine Matrixvariable "A" erzeugt und anschließend der Rang von "A" in der Variable "rang" gespeichert.
<syntaxhighlight lang="xml">
<variables>
<option name="A" type="matrix" cas="Evaluator" value="evaluateInR('matrix(c(1,2,3,4,5,6,7,8,9),3,3)')" />
<option name="rang" type="vector" cas="Evaluator" value="evaluateInR('rank([var=A])')" />
</variables>
</syntaxhighlight>

===Weitere Links===

[[Kategorie:Math-Evaluatorfunktion]]

Molecule

2018-12-11T11:15:16Z

Spobel:

{{Template:ChemEvaluatorfunktion|Parameter=Die Funktion kann 1-3 Parameter erwarten. Parameter 2 und 3 sind optional.

Die Methode ertwartet ein ''[[Atomarray|atomarray]]''(muss immer enthalten sein) einen ''[[Charge|charge]]'' und einen ''[[StateOfMatter|stateOfMatter]]''(optional).|Rückgabewert=Die Funktion gibt ein Molekül zurück.|Aufbau= <code>molecule(atomarray,[charge],[stateOfMatter])</code>|Hinweise=*Diese Moleküle können im Aufgabentext/Feedbacktext/etc. angezeigt werden.
*Diese Moleküle können zum rechnen im ChemEvaluator verwendet werden:
**<code>+,*</code>
**<code>contains, consostOf, compareNumberOfAtoms, checkOxidationState, checkStateOfMatter</code>
**<code>list</code>
**<code>isEmpty</code>|Beispiel=
1.<pre style="color:red">molcule(atomarray(atomarray_element(H,2), atomarray_Element(O)))</pre>

::=><code>H2O</code>

2. <pre style="color:red">molcule(atomarray(atomarray_element(H,2), atomarray_Element(O)), charge(2+))</pre>

::=><code>H2O2+</code>

3. <pre style="color:red">molcule(atomarray(atomarray_element(H,2), atomarray_Element(O)), charge(3+), stateOfMatter('aq'))</pre>

::=><code>H2O3+(aq)</code>

4. <pre style="color:red">molcule(atomarray(oxidationState(-'II',atomarray_element(H,2)), atomarray_Element(O)))</pre>

::=>[[Datei:H2o.jpg]]
}}

[[Category:Funktionen zur Erstellung von Molekülen]]

Versionshistorie (Jack2)

2018-10-31T10:40:29Z

Spobel:

== August 2018 ==
* ''29. August 2018'': '''JACK 2.5'''
** Der Lösungsüberblick zu Kursen ist nun in den Kurseinstellungen ein- und ausschaltbar. Standardmäßig sind diese bei schon existierenden Kursen sichtbar.
** Der '''Evaluator''' unterstützt nun auch OpenChem mithilfe des [[ChemEvaluator]]s:
*** arith1: [[Plus]], [[Times]], [[UnaryMinus]], [[UnaryPlus]]
*** chemistry1: [[CheckOxidationState]], [[CheckStateOfMatter]], [[CompareNumberOfAtoms]], [[ConsistOf]], [[Contains]]
*** list1: [[List]]
*** logic1: [[And]], [[False]], [[Not]], [[Or]], [[True]]
*** molecule1: [[AtomarryElement]], [[Atomarray]], [[Charge]], [[Molecule]], [[OxidationState]], [[StateOfMatter]]
*** nums1: [[E]], [[PI]]
*** periodictable_group1 - 18
*** testterminal_jack: [[IsEmpty]]
*** variable_jack: [[Exercise]], [[FillIn]]
** Des Weiteren verhält sich das Zeichen „/“ in Mathematik-Formeln nun exakt (d.h. als Bruch). Möchte man eine Dezimalzahl erzeugen, so kann man den „:“-Operator nutzen.
*** Neue MathEvaluator-Funktionen: [[IsVector]], [[IsNVector]], [[GetFromMatrix]], [[GetFromVector]]

== Juni 2018 ==
* ''13. Juni 2018'': Die [[:Kategorie:Testfunktionen|Testfunktionen]] des Evaluators haben Zuwachs bekommen: Mit [[IsVector]] und [[IsNVector]] können nun Vektoren überprüft werden.
* ''6. Juni 2018'': Die Dokumentation für den [[TracingChecker]] und den [[KovidaChecker]] für Programmieraufgaben ist nun auch in diesem Wiki verfügbar.
* ''5. Juni 2018'': Die meisten JACK-Instanzen wurden eine neue Version mit vielen kleinen Fehlerkorrekturen und Verbesserungen aktualisiert.

== April 2018 ==
* ''25. April 2018'': Mit der neuen Evaluator-Funktion [[ImplodeList]] können nun Listen in Zeichenketten verwandelt werden.

== November 2017 ==
* ''20. November 2017'': Der Evaluator 2.0 läuft nun auch auf http://jack.s3.uni-due.de. Hinweise zu notwendigen Änderungen an formularbasierten Aufgaben findet man unter [[Migration zur Evaluator 2 Syntax]]

== Oktober 2017 ==
* ''04. Oktober 2017'': Die Funktionen des [[Evaluator|Evaluators]] sind nun in diesem Wiki kategorisiert. Eine Übersicht aller Kategorien findet man unter [[:Kategorie:Evaluatorfunktionenkategorie|Evaluatorfunktionenkategorien]]

== September 2017 ==
* ''29. September 2017'': Auf der Spielwiese läuft seit heute Version 2 vom [[Evaluator]]. Neu ist insbesondere, dass Lehrende in den Funktionen anstatt CAS-Syntax sogenannte [[:Kategorie:Konstruktor|Konstruktoren]] verwendet werden müssen. Dies zieht ggf. Änderungen nach sich, z.B. an der Funktion [[equalsExpr]].

== August 2017 ==
* ''30. August 2017'': In [[Fill In|Fill-In-Aufgaben]] können die Warnungen des Checkers bei leerer Eingabe unterdrückt werden. Die Dokumentation dazu findet man im Artikel [[Stage]] in der Erläuterung des Tags '''exercise'''. Bisher kann dieses Feature nur auf der Spielwiese verwendet werden.
* ''29. August 2017'': Sage läuft jetzt in JACK auf Version 8.0
* ''29. August 2017'': [[Fill In|Fill-In-Aufgaben]] erhalten eine [[Evaluator-Konsole]] für Lehrende, um Aufgaben einfacher Testen zu können.

== Juli 2017 ==
* ''5. Juli 2017'': Der Server jack-server05.s3.uni-due.de (Spielwiese) wird ab ca. 14:45 Uhr offline sein um ihn zu aktualisieren. Bis ca. 16 Uhr sollten alle Maßnahmen abgeschlossen und der Server wieder verfügbar sein. Vielen Dank für ihr Verständnis!

== Juni 2017 ==
* ''29. Juni 2017'': Eine neue stabile Version findet sich auf allen JACK-Servern, eine neue Testversion (2.4.2) befindet sich auf der Spielwiesen-Instanz! Im Wesentlichen beinhaltet die neue Version zahlreiche Bugfixes.
* ''19. Juni 2017'': Herzlich Willkommen auf dem Feature-News-Ticker. Auf dieser Seite stellen wir in Zukunft neue Features innerhalb von JACK vor und dokumentieren ihre Verwendung. Bitte schauen Sie also regelmäßig rein.

List

2018-08-28T14:06:34Z

Spobel:

===Beschreibung===
Die Funktion ''list'' dient als Konstruktor für eine Liste. Es können Objekte und Funktionen, die Objekte zurückgeben als Elemente hinzugefügt werden.

'Besonderheit' an diesem Typ: wird eine [[List]]e als Paramter erwartet, kann auch ein beliebiges Objekt übergeben werden, dieses wird automatisch in eine [[List]]e übersetzt und das [[Objekt]] bildet das einzige Element dieser Liste.

===Syntax===
list(Objekt param1, Funktion param2, ...)

===Parameter===
* '''param1''' - Objekt z.B. Zahl oder Matrix
* '''param2''' - Funktion, die ein Objekt zurück gibt
* ... - beliebige Anzahl Elemente

===Return Value===
* Gibt die Liste zurück

===Beispiele===
list(vector(1,1),vector(1,2))

OpenMath:
<OMOBJ><OMA><OMS cd="list1" name="list"/><OMA><OMS cd="linalg2" name="vector"/><OMI>1</OMI><OMI>1</OMI></OMA><OMA><OMS cd="linalg2" name="vector"/><OMI>1</OMI><OMI>2</OMI></OMA></OMA></OMOBJ>

LaTeX:
<math>\{ \begin{pmatrix} 1 \\ 1 \end{pmatrix} , \begin{pmatrix} 1 \\ 2 \end{pmatrix} \}</math>

[[Kategorie:Evaluatorfunktion]][[Kategorie:Konstruktoren]][[Kategorie:Listfunktionen]]

Log

2018-08-21T09:16:14Z

Spobel:

=== Beschreibung ===
Die Funktion ''log'' beschreibt die Logarithmusfunktion zur angegebenen Basis. Der erste Parameter stellt die Basis dar. Der zweite Parameter ist eine rationale Zahl. Zu diesem zweiten Parameter wird der Logarithmus berechnet. Die Rückgabe ist eine rationale Zahl.

=== Syntax ===
log([[Gleitkommazahl]] basis, [[Gleitkommazahl]] zahl)

=== Parameter ===
* '''basis''' - [[Gleitkommazahl]], Basis zu der die Logarithmusfunktion arbeitet
* '''zahl''' - [[Gleitkommazahl]], auf die die Logarithmusfunktion angewendet wird

=== Return Value ===
* Gibt eine [[Gleitkommazahl]] zurück

=== Beispiele ===
==== Standardfälle ====
log(e, 100) --> returns 4.605170185988092
log(10, 1) --> returns 0
log(2, 1) --> returns 0

==== Benutzung von Variablen ====
log(10, [pos=1])
log([var=a], [pos=4])

=== Hinweise ===
* Aufgrund von der Rechengenauigkeit des Computers, wird in jedem Fall eine rationale Zahl zurückgegeben. Sollte der tatsächliche Funktionswert irrational sein, wird entsprechend gerundet.
* log(a,b) == log(b)/log(a)

[[Kategorie:Evaluatorfunktion]]

GetFromSet

2018-07-03T11:24:36Z

Spobel:

=== DEPRECTAED ===
Diese Funktion wird im Evaluator 2 nicht mehr unterstützt. Die Funktion [[GetFromList]] bietet die gleiche Funktionalität.

GetFromOrderedSet

2018-07-03T11:24:10Z

Spobel: /* DEPRECTAED */

=== DEPRECTAED ===
Diese Funktion wird im Evaluator 2 nicht mehr unterstützt. Die Funktion [[GetFromOrderedList]] bietet die gleiche Funktionalität.

Log

2018-02-27T10:07:22Z

Spobel:

=== Beschreibung ===
Die Funktion ''log'' beschreibt die natürliche Logarithmusfunktion zur Basis <math>e</math>. Die Funktion erwartet eine rationale Zahl und gibt eine rationale Zahl zurück.
Die Funktion ''log'' bietet die Möglichkeit einen zweiten Parameter einzugeben. Nutzt man die Funktion mit zwei Parametern, stellt der erste Parameter die Basis dar.

=== Syntax ===
log([[Gleitkommazahl]] zahl)
log([[Gleitkommazahl]] basis, [[Gleitkommazahl]] zahl)

=== Parameter ===
* '''zahl''' - [[Gleitkommazahl]], auf die die Logarithmusfunktion angewendet wird
* '''basis''' - [[Gleitkommazahl]], Basis zu der die Logarithmusfunktion arbeitet

=== Return Value ===
* Gibt eine [[Gleitkommazahl]] zurück

=== Beispiele ===
==== Standardfälle ====
log(100) --> returns 4.605170185988092
log(1) --> returns 0
log(2,1) --> returns 0

==== Benutzung von Variablen ====
log([pos=1])
log([var=a])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>5</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMF dec=\"13.7465\"/></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>5</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMF dec=\"13.7465\"/></OMOBJ>"));

}

@Test
public void testLog1() {
assertEquals(Math.log(100), Evaluator.getNumberResult("log(100)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLog2() {
assertEquals(Math.log(197), Evaluator.getNumberResult("log(197)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLog3() {
assertEquals(Math.log(100), Evaluator.getNumberResult("log('100')", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLog4() {
assertEquals(Math.log(197), Evaluator.getNumberResult("log('197')", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithInput1() {
assertEquals(Math.log(5), Evaluator.getNumberResult("log([pos=1])", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithInput2() {
assertEquals(Math.log(13.7465),
Evaluator.getNumberResult("log([pos=2])", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testLogWithVariables1() {
assertEquals(Math.log(5), Evaluator.getNumberResult("log([var=a])", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithVariables2() {
assertEquals(Math.log(13.7465),
Evaluator.getNumberResult("log([var=b])", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLogWithExpressions1() {
assertEquals(Math.log(Math.log(12)),
Evaluator.getNumberResult("log(log(12))", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testLogWithExpressions2() {
assertEquals(Math.log(Math.log(Math.log(12))),
Evaluator.getNumberResult("log(log(log(12)))", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testLogWithPointNumbers1() {
assertEquals(Math.log(1.0), Evaluator.getNumberResult("log(1.0)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithPointNumbers2() {
assertEquals(Math.log(.1), Evaluator.getNumberResult("log(0.1)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithPointNumbers3() {
assertEquals(Math.log(.1234), Evaluator.getNumberResult("log(0.1234)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test(expected = FunctionInvalidArgumentException.class) // NaN
public void testLogAtDefinition1() {
Evaluator.getNumberResult("log(-1)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentException.class) // NaN
public void testLogAtDefinition2() {
Evaluator.getNumberResult("log(-0.1)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentException.class) // NaN
public void testLogAtDefinition3() {
Evaluator.getNumberResult("log(0)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testLogWithWrongInputCharacter() {
Evaluator.getNumberResult("log(a)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testLogWithTwoArguments() {
Evaluator.getNumberResult("log(2, 1)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testLogWithThreeArguments() {
Evaluator.getNumberResult("log(1, 23, 4)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testLogWithMissingExerciseVariable() {
Evaluator.getNumberResult("log('[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testLogWithMissingInput() {
Evaluator.getNumberResult("log('[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Aufgrund von der Rechengenauigkeit des Computers, wird in jedem Fall eine rationale Zahl zurückgegeben. Sollte der tatsächliche Funktionswert irrational sein, wird entsprechend gerundet.
* log(a,b) == log(b)/log(a)

[[Kategorie:Evaluatorfunktion]]

IsTuple

2018-02-26T13:15:41Z

Spobel:

===Beschreibung===
''isTuple'' gibt wahr(true) zurück falls der angegebene Parameter ein [[Tupel]], nicht wahr(false) ansonst.

===Syntax===
isTuple(a)

===Parameter===
* '''a''' - [[Tupel]]

===Return Value===
* Gibt True oder False zurück.

===Beispiele===
<math>isTuple(tuple(2,3,4,5,6,7))</math> --> returns <math>True</math>

<math>isTuple(tuple())</math> --> returns <math>True</math>

<math>isTuple(list(2,3,4,5,6,7))</math> --> returns <math>False</math>

<math>isTuple(2)</math> --> returns <math>False</math>

[[Kategorie:Evaluatorfunktion]][[Kategorie:Testfunktionen]][[Kategorie:Tupelfunktionen]]

IsNTuple

2018-02-26T13:15:18Z

Spobel:

===Beschreibung===
''isNTuple'' gibt wahr(true) zurück falls der erste Parameter ein [[Tupel]] ist UND der zweite Parameter die Anzahl der Tupel-Elemente entspricht.

===Syntax===
isNTuple(a,b)

===Parameter===
* '''a''' - [[Tupel]]
* '''b''' - [[Ganzzahl]]

===Return Value===
* Gibt True oder False zurück.

===Beispiele===
<math>isNTuple(tuple(1,2,3,4),4)</math> --> returns <math>True</math>

<math>isNTuple(tuple(),0)</math> --> returns <math>True</math>

<math>isNTuple(tuple(2,3,4,5,6,7),1)</math> --> returns <math>False</math>

<math>isNTuple(list(2,3,4),3)</math> --> returns <math>False</math>

<math>isNTuple(2)</math> --> returns <math>False</math>

[[Kategorie:Evaluatorfunktion]][[Kategorie:Testfunktionen]][[Kategorie:Tupelfunktionen]]

Kategorie:Tupelfunktionen

2018-02-26T13:14:24Z

Spobel: Leere Seite erstellt

Tuple

2018-02-26T13:13:57Z

Spobel:

===Beschreibung===
Die Funktion ''tuple'' dient als Konstruktor für einen Tuple. Es können Objekte und Funktionen, die Objekte zurückgeben als Elemente hinzugefügt werden. Ebenfalls können in Tupeln weitere Tupeln enthalten sein.

===Syntax===
tuple([[Objekt]] param1, [[Objekt]] param2, ...)

===Parameter===
* '''param1''' - [[Objekt]] z.B. Zahl, Zeichenkette oder Matrix
* '''param2''' - [[Objekt]] z.B. Zahl, Zeichenkette oder Matrix

===Return Value===
* Gibt das resultierende Tupel zurück

===Beispiele===
tuple(1,'Hallo')
tuple('Eins', 2, 3.3, 'Vier')

OpenMath:
<OMOBJ><OMA><OMS cd="ecc" name="Tuple"/><OMI>1</OMI><OMSTR>Hallo</OMSTR></OMA></OMOBJ>
<OMOBJ><OMA><OMS cd="ecc" name="Tuple"/><OMSTR>Eins</OMSTR><OMI>2</OMI><OMF dec=3.3><OMSTR>Vier</OMSTR></OMA></OMOBJ>

LaTeX:
<math>(1, 2)</math>
<math>(Eins, 2, 3.3, Vier)</math>

[[Kategorie:Evaluatorfunktion]][[Kategorie:Konstruktoren]][[Kategorie:Tupelfunktionen]]

IsNTuple

2018-02-26T13:11:44Z

Spobel:

Variablen (Jack2)

2018-02-13T13:27:13Z

Spobel: /* Nutzung einer CAS-Funktion */

=== Beschreibung ===

Eine wichtige Funktion von [[FormBased|formularbasierten]] Aufgaben ist die Parametrisierung der Aufgaben durch Variablen. Dadurch können beliebig viele Instanzen derselben Aufgabe, bspw. mit verschiedenen Zahlenwerten generiert werden. Eine Variable definiert nach dem Verständnis von JACK einen oder mehrere (z.B. eine Menge) solcher variabler Werte. Sie kann zufällig oder nach einer vorgegebenen Berechnungsvorschrift bestimmt werden und trägt einen für die Aufgabe eindeutigen Namen, welcher dazu dient, sie zu referenzieren.

=== Beispiel ===
[[Datei:Bestimmedenggt.PNG|500px]]

Die obige Beispielaufgabe dient dazu, die Idee der Parametrisierung von Aufgaben zu erläutern. Der Lernende soll in einer typischen Mathematikaufgabe den größten gemeinsamen Teiler von den beiden Zahlen <math>x_1 = 120</math> und <math>x_2 = 125</math> berechnen. Natürlich könnte diese Aufgabe auch mit zwei beliebigen anderen, zufällig gewählten natürlichen Zahlen gestellt werden und der größte gemeinsame Teiler stets berechnet werden. Es wäre daher denkbar, die beiden Zahlen <math>x_1</math> und <math>x_2</math> zufällig aus einer vorgegebenen Menge ziehen zu lassen und man erhielte für jede Möglichkeit eine andere Instanz derselben Aufgabe. Da man in diesem Fall vermutlich zumeist 1 als größten gemeinsamen Teiler erhalten würde, bietet einem JACK jedoch auch die Möglichkeit, anders vorzugehen. So kann der eine Ausgangszahl als zufällige natürliche Zahl aus einem vorgegebenen Intervall gezogen werden und die Zahlen <math>x_1</math> und <math>x_2</math> anschließend mithilfe geeigneter ebenfalls zufällig gezogenen Faktoren ermittelt werden. Es können also bereits belegte Variablenwerte verwendet werden, um andere zu berechnen. Man beachte jedoch, dass der größte gemeinsame Teiler dadurch auch von den beiden zufällig gezogenen Faktoren abhängt, denn diese können ja auch gemeinsame Primfaktoren besitzen. Man benötigt also eine Funktion, welche einem den ggT von <math>x_1</math> und <math>x_2</math> berechnen kann.

=== Definition von Variablen in der ExerciseChain ===

Die Definition von Variablen geschieht in JACK in der [[ExerciseChain]] über das Tag <code><variables></code>. Jede Variable definiert man durch ein Tag <code><option></code> und gibt ihr einen Namen über das Attribut <code>name</code>. Referenziert werden können die Variablen anschließend über ihren Namen mittels des Platzhalters <code>[var=name]</code>. Die kann an allen Stellen innerhalb einer Aufgabe geschehen, also z.B. in der ExerciseChain, in der Aufgabenstellung, in Hinweisen oder auch im Feedback. Die Berechnungsvorschrift kann mithilfe verschiedener Funktionen geschehen, die hier vorgestellt werden sollen:

==== Ganzzahlige Zufallszahl aus einem vorgegebenen Intervall====
Dies geschieht durch die Angabe einer unteren und einer oberen Grenze des Intervalls mittels der Attribute <code>min</code> und <code>max</code>. Der folgende Eintrag wählt beispielsweise eine ganzzahlige Zufallszahl im Intervall [1,5] aus, also eine der Zahlen 1,2,3,4 und 5:

<syntaxhighlight lang="xml">
<option name="a" min="1" max="5" />
</syntaxhighlight>

==== Ziehen von Elementen aus einer Menge ====
Das Attribut <code>set</code> kann verwendet werden, um eine Menge zu definieren, aus der zufällig ein Element gezogen wird. Die folgende Variablendeklaration kann verwendet werden, um zufällig eine der ersten fünf Primzahlen zu ziehen:

<syntaxhighlight lang="xml">
<option name="a" set="{2,3,5,7,11}" />
</syntaxhighlight>

Die Mengenelemente können jedoch auch beliebige Zeichenketten sein und müssen nicht numerisch sein. Es ist also auch folgende Variablendeklaration möglich:

<syntaxhighlight lang="xml">
<option name="a" set="{x,y,z}" />
</syntaxhighlight>

==== Nutzung einer Evaluator-Funktion ====
Das Attribut <code>value</code> dient dazu, eine Funktion des [[Evaluator|Evaluators]] zu verwenden. Der [[Evaluator]] kennt einfache arithmetische Operationen und beherrscht eine Reihe von selbst-implementierten Funktionen. Außerdem können Computer Algebra Systeme über eigens dafür implementierte Funktionen angesprochen werden. Die folgende Variablendeklaration definiert eine Variable "b", welche das Quadrat der Variable "a" ist. Die Funktion [[Pow]] ist eine Evaluatorfunktion, welche zwei Argumente a,n entgegennimmt und daraus die Potenz <math>a^n</math> berechnet.

<syntaxhighlight lang="xml">
<option name="b" value="pow([var=a],2)" />
</syntaxhighlight>

==== Nutzung einer CAS-Funktion ====
Durch das Attribut <code>cas</code> können Computer Algebra Systeme auch direkt angesprochen werden. Erlaubte Werte des Attributs sind <code>sage</code> und <code>R</code>. Es kann dann das Attribut <code>value</code> verwendet werden, um eine Funktion des gewählten CAS zu benutzen. Die folgende Variablendeklaration berechnet die Fakultät der Variable "a" mit Hilfe von ''R'' und speichert diese in der Variable "b":

<syntaxhighlight lang="xml">
<option name="b" value="factorial([var=a])" cas="R" />
</syntaxhighlight>

==== Mengenvariablen ====
Bei den bisher besprochenen Variablentypen handelt es sich stets um Einzelelemente, also bspw. Zahlen oder Zeichenketten. JACK erlaubt jedoch auch komplexere Variablentypen, wie z.B. Mengen oder Matrizen. Dafür besitzt das <code><option></code>-Tag ein Attribut <code>type</code>, mit welchem der Variablentyp deklariert werden kann. Lässt man das Attribut weg, so handelt es sich um eine Einzelvariable, wie wir bereits oben gesehen haben. Mengenvariablen können auf verschiedene Weisen deklariert werden. Zum einen über die direkte Angabe der einzelnen Elemente, zum anderen können Mengen auch aus Computer Algebra Systemen gezogen werden. Eine Mengenvariable kann, wenn sie einmal mit einem Wert belegt ist, dazu verwendet werden, um weitere Funktionen auf ihr auszuführen. So kann man z.B. ein bestimmtes Element aus einer Menge ziehen oder auch den Mittelwert aller Elemente berechnen. Die einfachste Art, eine Mengenvariable zu deklarieren, ist die folgende:

<syntaxhighlight lang="xml">
<option name="M" type="set">
<element>2</element>
<element>3</element>
<element>5</element>
</option>
</syntaxhighlight>

Dadurch hat die Mengenvariable "M" die Elemente 2,3 und 5. Man könnte nun eine Funktion verwenden, die auf Mengen operiert, um auf diese Elemente zuzugreifen (z.B. [[GetFromSet]]). Zudem ist es auch möglich CAS-Funktionen zu verwenden, um eine Mengenvariable zu belegen. Der folgende Aufruf zieht fünf Elemente mit Hilfe der Normalverteilung mit Erwartungswert 0 und Standardabweichung 1 und verwendet dafür ''R'':

<syntaxhighlight lang="xml">
<option name="y" type="set" value="rnorm(5,0,1)" cas="R" />
</syntaxhighlight>

==== String-Variablen ====
In JACK können auch String-Variablen angelegt werden. Das ist hilfreich, wenn Aufgaben-, Feedback- bzw. Hinweistexte variabel gehalten werden sollen. Insbesondere kann man eine Menge mit String-Variablen erstellen, aus der dann mit entsprechenden Evaluator-Funktionen (bspw. [[GetFromSet]]) passende Strings ausgewählt werden.

Allgemein erstellt man eine String-Variable folgendermaßen:

<syntaxhighlight lang="xml">
<option name="aufgabentext" value="'Berechne die Summe aus 2 und 5'" />
</syntaxhighlight>

Man beachte, dass innerhalb des <code>value</code>-Attributs neben den herkömmlichen doppelten Anführungszeichen zusätzlich einfache Anführungszeichen stehen. Diese sind hier zwingend notwendig, damit JACK den Wert als String versteht.

Zum Erstellen einer Menge mit Strings verzichtet man hingegen auf die Anführungszeichen. In diesem Fall verfährt man genauso wie bei einer herkömmlichen Menge:

<syntaxhighlight lang="xml">
<option name="definitheit" type="set">
<element>A ist positiv definit</element>
<element>A ist positiv semidefinit</element>
<element>A ist negativ definit</element>
<element>A ist negativ semidefinit</element>
<element>A ist indefinit</element>
</option>
</syntaxhighlight>

==== Matrixvariablen ====
In gleicher Art und Weise wie Mengenvariablen erzeugt werden können, funktioniert dies auch für Matrizen. Dem Attribut <code>type</code> gibt man dafür den Wert <code>matrix</code>. Anschließend verwendet man ein CAS, um eine Matrix zu generieren. Ein CAS, welches eine Reihe von Funktionen zur Matrixerzeugung anbietet ist ''Sage''. In dem Artikel [[EvaluateInSage]] findet man eine Reihe von Beispielen, wie eine Matrixvariable mit Sage generiert werden kann.

==== McIndex-Variablen ====
''→ Hauptartikel:'' [[McIndex-Variablen]]

McIndex-Variablen finden in Multiple-Choice Aufgaben mit einem Pool an Aussagen Verwendung und ermöglichen das automatische Durchführen einer [[Distraktoranalyse]]. Sie fungieren dabei als Hilfsvariablen für die zufällige Auswahl aus einer oder mehreren Set-Variablen.

=== Konstanten ===
Außerdem bietet JACK die Möglichkeit Konstanten zu benutzen ohne sie vorher explizit in der exerciseChain deklarieren zu müssen. Momentan stehen die eulersche Zahl ''e'' und die Kreiszahl ''π'' als Konstanten zur Verfügung. Man kann in allen Situationen, in denen man eine Variable verwenden könnte, auch <code>[var=E]</code> für ''e'' oder <code>[var=PI]</code> für ''π'' schreiben.

Daraus folgt allerdings, dass man beim Erstellen einer Aufgabe selbst keine Variablen mit den Namen <code>E</code> oder <code>PI</code> erstellen darf.

Evaluator

2018-02-13T11:59:17Z

Spobel:

=== Beschreibung ===
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]] genutzt, als auch um die Prüfregeln für richtige Antworten bzw. Feedbacknachrichten in [[Fill In|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 [[Fill In|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">
<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:

<syntaxhighlight lang="xml">
<option result="funktion1(...)&&funktion2(...)">Feedback</option>
</syntaxhighlight>

Die XML-Entity "&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 ("!").

=== Variablen erstellen ===
Der Evaluator kann beim Erzeugen aufgabenbezogener [[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.

<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.

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.

<syntaxhighlight lang="xml">
<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.

=== 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 [[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 ===
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.

* [[:Kategorie:Evaluatorfunktion|Evaluatorfunktion]]
* [[:Kategorie:Konstruktoren|Konstruktoren]]
* [[:Kategorie:Ausdruckfunktionen|Ausdruckfunktionen]]
* [[:Kategorie:Zeichenkettenfunktionen|Zeichenkettenfunktionen]]
* [[:Kategorie:Booleanfunktionen|Booleanfunktionen]]
* [[:Kategorie:Listfunktionen|Listfunktionen]]
* [[:Kategorie:Vektorfunktionen|Vektorfunktionen]]
* [[:Kategorie:Matrixfunktionen|Matrixfunktionen]]
* [[:Kategorie:Testfunktionen|Testfunktionen]]
* [[:Kategorie:Sparqlfunktionen|Sparqlfunktionen]]
* [[Best Practice für den Evaluator]]

===Hinweise===
* Wenn man zwei oder mehr Funktionen miteinander verknüpft fallen die Anführungszeichen weg: ''equalsExpr(evalEq('5','5'),'0')''

Formeleditor

2018-01-31T13:53:05Z

Spobel:

JACK bietet die Möglichkeit, Fill-In-Aufgaben um einen Editor zu erweitern, der die Eingabe mathematischer Ausdrücke vereinfacht. Zum Einbinden des Editors in eine Aufgabe muss der <code>exercise</code>-Tag um das Attribut <code>editor</code> mit einem passenden Wert ergänzt werden.

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="iso-8859-1"?>
<exercise type="fillIn" editor="basic">
...
...
</exercise>
</syntaxhighlight>

In dem Beispiel hat <code>editor</code> den Wert <code>basic</code>.

Der Editor bietet Palette mit einer Vielfalt an mathematischen Ausdrücken an, die außerdem erweitert werden kann. In JACK gibt es die Möglichkeit eigene Paletten ([[Templatepaletten]]) zu erstellen und vorgefertigte [[Standardpaletten]] zu nutzen.

Um [[Standardpaletten]] einzubinden genügt es den Namen der Palette wie oben beschrieben anzugeben.

Um [[Templatepaletten]] einzubinden, muss die selbsterstellte XML Datei der Aufgabe hinzugefügt werden. Zusätzlich muss in dem <code>editor</code>-Tag der Stage Datei der Name der Datei + Dateiendung übergeben werden. Bsp.: <code>editor="MyPalette.xml"</code>

===Hinweis===
Es gibt die Möglichkeit die FillIn Kästchen des Formeleditors zu nutzen, ohne eine Palette anzuzeigen. Hierzu kann <code>editor="invisible"</code> gesetzt werden.

* [[Templatepaletten]]
* [[Standardpaletten]]

Stage (Jack2)

2018-01-31T13:49:39Z

Spobel:

Um die Inhalte einer Stufe zu definieren, wie z.B. Fragetext, Antwortoptionen, Feedback, etc. ist für jede Stufe eine weitere [[XML-Dateien|XML-Datei]] notwendig. Der Name
dieser XML-Datei ist beliebig und muss nur an der entsprechenden Stelle in der [[ExerciseChain]] referenziert werden. Zur Zeit gibt es drei mögliche Fragetypen
für eine Stufe: [[Multiple Choice]], [[Fill In]] und [[SCList]] (eine Tabelle mit Checkboxen). Die XML-Dateien der jeweiligen Fragetypen sind unterschiedlich und werden
in den folgenden Abschnitten detailliert erläutert.

=== Aufbau ===
Das Grundgerüst einer solchen Stufendefinition ist jedoch immer ähnlich und weist für alle Fragetypen gemeinsame Tags
auf. Es hat die folgende Form:

<syntaxhighlight lang="xml" line='line'>
<?xml version="1.0" encoding="iso-8859-1"?>
<exercise type="" editor="">
<input condition="">
<inputvalue name="" type="" />
</input>
...
{Stufenspezifischer Bereich}
...
<advice>
<option> Hinweistext </option>
</advice>
<skipmessage> Nachricht zum Überspringen </skipmessage>
<output>
<outputvalue value="" type="" />
</output>
</exercise>
</syntaxhighlight>

Die gemeinsamen Tags haben die folgende Bedeutung:
* '''exercise:''' Das Wurzeltag einer jeden Stufendefinition. Es besitzt das Attribut <code>type</code>, bei welchem der Fragetyp der jeweiligen Stufe einzutragen ist. Erlaubte Werte sind hier <code>mc</code>, <code>fillIn</code> und <code>sclist</code>. Des weiteren kann man über das Attribut <code>editor</code> steuern, ob die Stufe einen [[Formeleditor]] bei Fill-In-Kästchen besitzen soll. Mögliche Werte sind <code>true</code>, <code>false</code> und der Name des jeweiligen Editors. Statt dem Attribut den Wert <code>false</code> zuzuordnen, kann es auch einfach weggelassen werden. Bei [[Fill In]]-Aufgaben können mittels des Attributs <code>suppressEmptyWarnings</code> die automatischen Warnungen des Checkers bei leergelassenen Fill-In-Kästchen unterdrückt werden. Auch hier ist der Defaultwert des Attributs <code>false</code> und es akzeptiert die Werte <code>true</code> und <code>false</code>. Es gibt die Möglichkeit mithilfe des Attributs <code>editor</code> einen Formeleditor in eine Stage einzubinden. Eine ausführliche Beschreibung ist auf der Seite [[Formeleditor]] zu finden.
* '''input:''' In diesem Tag werden die Variablen definiert, die von der ExerciseChain übergeben werden. Für jeden Tag <code>input</code> muss ein Tag <code>inputvalue</code> definiert werden. Gibt es keine <code>input</code>-Tags in der ExerciseChain, so bleibt dieses Tag leer, es muss jedoch zwingend vorhanden sein. Über das Attribut <code>condition</code> kann außerdem eine Bedingung angegeben werden, die vom System geprüft werden soll. Will man bspw. eine Parabel <math>f(x) = ax^2 + bx + c</math> mit Variablen <math>a,b,c</math> definieren, so sollte <math>a \neq 0</math> gelten. Ist die Bedingung nicht erfüllt, so wird die Aufgabe dem Studierenden nicht angezeigt und er erhält eine Fehlermeldung. Dieses Attribut kann auch weggelassen werden.
* '''inputvalue:''' Definiert eine [[Variablen|Variable]] für die lokale Variablenliste. Über das Attribut <code>name</code> wird der Name für die lokale Variablenliste bestimmt. Der Name muss dabei nicht mit dem Namen der Variable in der globalen Variablenliste übereinstimmen, es ist jedoch meist sinnvoll diesen beizubehalten. Außerdem wird über das Attribut <code>type</code> der Typ der Variable angegeben. Mögliche Werte bei diesem Attribut sind <code>integer</code> (für ganze Zahlen), <code>double</code> (für Dezimalzahlen), <code>string</code> (für sonstige Zeichenketten) und <code>set</code> für Mengen. Die Defaulteinstellung dieses Attributs ist <code>string</code>.
* '''advice:''' Über das Tag <code>advice</code> können Hinweise gegeben werden. Für jeden Hinweis muss ein Tag <code>option</code> erzeugt werden. Der Studierende kann diese Hinweise über das Klicken des Hinweis-Buttons angezeigt bekommen.
* '''skipmessage:''' Hier kann eine Nachricht angegeben werden, die beim Überspringen der Aufgabenstufe angezeigt wird. Beispielsweise kann dem Studierenden hier die Lösung der übersprungenen Stufe erläutert werden. Gibt man der '''letzten''' Aufgabenstufe eine <code><skipmessage></code>, zeigt der Überspringen-Button stattdessen '''Lösung anzeigen''' an, andernfalls wird der Button hier nicht angezeigt.
* '''output:''' Für jede Variable, die an die ExerciseChain zurückgegeben werden soll, muss in diesem Tag ein Tag vom Typ <code>outputvalue</code> erstellt werden. Sollen keine Variablen zurückgegeben werden, so bleibt dieses Tag leer. Es muss jedoch zwingend vorhanden sein.
* '''outputvalue:''' Gibt eine Variable an die ExerciseChain zurück. Im Attribut <code>value</code> wird der Wert der Variable angegeben. Dieser Wert kann ein beliebiger String sein, den der [[Evaluator]] evaluieren kann. Möchte man eine studentische Eingabe bei einer Fill-In-Aufgabe zurückgeben, so kann man es mit <code>[pos=...]</code> referenzieren. Dabei muss nach dem Gleichheitszeichen die Nummer des Fill-In-Kästchens eingetragen werden. JACK nummeriert die Fill-In-Kästchen beginnend mit 1. Das erste Fill-In-Kästchen wird also durch den Platzhalter <code>[pos=1]</code> referenziert, usw. (s. auch die Erklärung zum Tag <code>option</code> beim Fragetyp [[Fill In]]). Möchte man das Ankreuzmuster einer Multiple-Choice-Aufgabe zurückgeben, so belegt man das Attribut mit dem Wert <code>ticked</code>. Über das Attribut <code>type</code> wird zudem analog zum Tag <code>inputvalue</code> der Typ der Variable definiert.

=== LaTeX-Umgebung ===
In Fragetexten, Antworten, Hinweisen und Feedback kann jederzeit die Matheumgebung von LaTeX verwendet werden. Dies geschieht, indem man einfach den LaTeX-Code eingefasst in <code>$</code>-Zeichen an der entsprechenden Stelle in das XML-Dokument schreibt.

'''Wichtig''' ist jedoch, dass ein Fill-In-Kästchen niemals in einer Matheumgebung stehen und in Dropdown-Menüs kein LaTeX-Code stehen darf!

=== Bilder ===
Bilder können ebenfalls an allen Stellen in Aufgaben eingepflegt werden. Dies geschieht im XML-Dokument über den Befehl <code>[img name=" "] DATEINAME.ENDUNG [/img]</code>. Dabei muss DATEINAME.ENDUNG durch den richtigen Dateinamen des Bildes sowie die richtige Endung ersetzt werden. Über das Attribut <code>name</code> kann man dem Bild eine Unterschrift geben.

'''Achtung:''' Möchte man Bilder benutzen, die man nicht selbst erstellt hat, sollte man die Urheberrechte des Bildes prüfen!

=== HTML ===
Man kann an beliebiger Stelle HTML verwenden. Dabei muss darauf geachtet werden, dass die entsprechenden Tags nicht von spitzen Klammern eingefasst sind (diese sind den XML-Tags vorbehalten), sondern durch die jeweilige XML-Notation ersetzt werden. Also <code>&lt;</code> statt <code><</code> und <code>&gt;</code> statt <code>></code>.

Möchte man also beispielsweise seinen Text fett markieren, schreibt man nicht <code>fett gedruckter Text</code>, sondern <code>&lt;b&gt;fett gedruckter Text&lt;/b&gt;</code>.

=== Graphen ===
Es besteht an den gleichen Stellen wie Bilder und Latex-Code auch die Möglichkeit, dynamisch (interaktive) Graphen mit Hilfe von Javascript zu erstellen.

''→ Hauptartikel:'' [[Graphen]]

IEEERemainder

2018-01-29T08:29:39Z

Spobel:

=== Beschreibung ===

Die Funktion ''IEEEremainder'' berechnet die Remainder-Operation auf zwei Argumente, wie es in dem IEEE 745 Standtard beschrieben ist [https://de.wikipedia.org/wiki/IEEE_754#Aritmetik_und_Quadratwurzel]. Die Funktion erwartet zwei Zahlen und gibt das entsprechende Ergebnis zurück.

=== Syntax ===
IEEEremainder([[Gleitkommazahl]] f1, [[Gleitkommazahl]] f2)

=== Parameter ===
* '''f1''' - Zähler
* '''f2''' - Nenner

=== Return Value ===
*Gibt den Rest-Wert zurück, wenn f1 durch f2 geteilt wird

=== Beispiele ===
==== Standardfälle ====
IEEEremainder(4,2) --> returns 0
IEEEremainder(3,2) --> returns -1

==== Benutzung mit Variablen ====
IEEEremainder([pos=1],[pos=2])
IEEEremainder([var=a],[var=b])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>20</OMI></OMOBJ>"));
fillInVariableMap.put(3, OMConverter.toObject("<OMOBJ><OMI>-10</OMI></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>20</OMI></OMOBJ>"));
exerciseVariableMap.put("c", OMConverter.toObject("<OMOBJ><OMI>-10</OMI></OMOBJ>"));

}

@Test
public void testIEEERemainder1() {
assertEquals(-1, Evaluator.getNumberResult("IEEEremainder(3, 2)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder2() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder(4, 2)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder3() {
assertEquals(1, Evaluator.getNumberResult("IEEEremainder(10, 3)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder4() {
assertEquals(-1, Evaluator.getNumberResult("IEEEremainder(11, 3)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder5() {
assertEquals(-1, Evaluator.getNumberResult("IEEEremainder(27, 4)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder6() {
assertEquals(-2, Evaluator.getNumberResult("IEEEremainder(28, 5)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test // It returns for Example 1.800000000XXX not 1.8
public void testIEEERemainderWithPointNumberResults1() {
assertEquals(1.8, Evaluator.getNumberResult("IEEEremainder(17.8, 4)", exerciseVariableMap, fillInVariableMap),
0.00001);
}

@Test
public void testIEEERemainderWithPointNumberResults2() {
assertEquals(1.4, Evaluator.getNumberResult("IEEEremainder(17.8, 4.1)", exerciseVariableMap, fillInVariableMap),
0.00001);
}

@Test
public void testIEEERemainderWithPointNumberResults3() {
assertEquals(0.1,
Evaluator.getNumberResult("IEEEremainder(-16.3, 4.1)", exerciseVariableMap, fillInVariableMap), 0.00001);
}

@Test
public void testIEEERemainderWithPointNumberResults4() {
assertEquals(1.4,
Evaluator.getNumberResult("IEEEremainder(17.8, -4.1)", exerciseVariableMap, fillInVariableMap), 0.00001);
}

@Test
public void testIEEERemainderWithPointNumberResults5() {
assertEquals(-1.4,
Evaluator.getNumberResult("IEEEremainder(-17.8, -4.1)", exerciseVariableMap, fillInVariableMap), 0.00001);
}

@Test
public void testIEEERemainderWithInput1() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder([pos=1], 4)", exerciseVariableMap, fillInVariableMap),
0);

}

@Test
public void testIEEERemainderWithInput2() {
assertEquals(0,
Evaluator.getNumberResult("IEEEremainder([pos=2], [pos=3])", exerciseVariableMap, fillInVariableMap),
0);
}

@Test
public void testIEEERemainderWithVariables1() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder([var=a], 4)", exerciseVariableMap, fillInVariableMap),
0);
}

@Test
public void testIEEERemainderWithVariables2() {
assertEquals(0,
Evaluator.getNumberResult("IEEEremainder([var=b], [var=c])", exerciseVariableMap, fillInVariableMap),
0);
}

@Test
public void testIEEERemainderWithExpressions1() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder('15', 'IEEEremainder(10, 3)')", exerciseVariableMap,
fillInVariableMap), 0);

}

@Test
public void testIEEERemainderWithExpressions2() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder('IEEEremainder(10, 3)', 'IEEEremainder(10, 3)')",
exerciseVariableMap, fillInVariableMap), 0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testIEEERemainderWithWrongInputCharacter() {
Evaluator.getNumberResult("IEEEremainder(17.8, a)", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIEEERemainderWithOneArgument() {
Evaluator.getNumberResult("IEEEremainder(8)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIEEERemainderWithThreeArguments() {
Evaluator.getNumberResult("IEEEremainder(3, 2, 8)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIEEERemainderWithMissingExerciseVariable() {
Evaluator.getNumberResult("IEEEremainder('[var=j]', '3')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIEEERemainderWithMissingInput() {
Evaluator.getNumberResult("IEEEremainder('[pos=42]', '3')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentException.class)
public void testIEEERemainderAtZero() {
Evaluator.getNumberResult("IEEEremainder(5, 0)", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

[[Kategorie:Evaluatorfunktion]]