Divide: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
 
(31 dazwischenliegende Versionen von 5 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
===Zugehörige Evaluatoren===
*'''MathEvaluator'''
*'''ChemEvaluator'''
===Beschreibung===
===Beschreibung===
Bei der ''Division'' wird die eine Zahl durch die andere Zahl geteilt, z.B. .  
Bei der ''Division'' wird die eine Zahl durch die andere Zahl geteilt und soweit wie möglich gekürzt.  
 
Dabei wird nicht mehr automatisch gerundet. Soll der Bruch als Dezimalzahl ausgegeben werden, kann die Funktion <code>round()</code> genutzt werden.


===Syntax===
===Syntax===
  a/b
  a:b
divide(a,b)


===Parameter===
===Parameter===
* '''a''' - [[Gleitkommazahl]]
* '''a''' - [[Objekt]]
* '''b''' - [[Gleitkommazahl]]
* '''b''' - [[Objekt]]


===Return Value===
===Return Value===
* Gibt eine expresseion zurück
* Gibt eine [[Ganzzahl]] oder einen Bruch zurück
Es wird soweit wie möglich die Eingabe gekürzt.


===Beispiele===
===Beispiele===
  <math>\frac{1}{4}</math>   --> returns 0.25
In Plain-Umgebung:
 
  1:4    -->  returns 1:4 in Zeichenketten, \(1 \div 4\) in LaTeX
  <math>\frac{1.5}{2}</math>    --> returns 0.75
 
divide(1, 4)   -->  returns 1:4 in Zeichenketten, \(1 \div 4\) in LaTeX
====JUnit Tests====
<span class="mw-customtoggle-myDivision">[Anzeigen]</span>
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
}
 
@Test
public void testDivision1() {
assertEquals(2, Evaluator.getNumberResult("8/4", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivision2() {
assertEquals(0.25, Evaluator.getNumberResult("1/4", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivision3() {
assertEquals(0.75, Evaluator.getNumberResult("1.5/2", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test(expected = FunctionInvalidArgumentException.class)
public void testDivision4() {
Evaluator.getNumberResult("1/0", exerciseVariableMap, fillInVariableMap);
fail();
}
 
@Test
public void testDivisionWithVariables1() {
assertEquals(1, Evaluator.getNumberResult("[var=a]/3", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithVariables2() {
assertEquals(1, Evaluator.getNumberResult("3/[var=a]", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithInput1() {
assertEquals(1, Evaluator.getNumberResult("[pos=1]/3", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithInput2() {
assertEquals(1, Evaluator.getNumberResult("3/[pos=1]", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithNegativeNumbers1() {
assertEquals(-.5, Evaluator.getNumberResult("-1 / 2", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithNegativeNumbers2() {
assertEquals(-.5, Evaluator.getNumberResult("1 / -2", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithNegativeNumbers3() {
assertEquals(-2, Evaluator.getNumberResult("-1 / 0.5", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithNegativeNumbers4() {
assertEquals(2, Evaluator.getNumberResult("2.22 / 1.11", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithEncapsulation1() {
assertEquals(2, Evaluator.getNumberResult("1 / (1 / 2)", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testDivisionWithEncapsulation2() {
assertEquals(.5, Evaluator.getNumberResult("1 / (1 / (1 / 2))", exerciseVariableMap, fillInVariableMap), 0.0);
}


@Test
==== Standardfälle ====
public void testDivisionWithEncapsulation3() {
'''Jack2:'''
assertEquals(.5,
divide(1,4)   --> returns 0,25
Evaluator.getNumberResult("1 / (1 / (1 / (1 / (1 / 2))))", exerciseVariableMap, fillInVariableMap),
1:4            --> return 0,25
0.0);
}


@Test
'''Jack3:'''
public void testDivisionWithEncapsulation4() {
divide(1,4)   --> returns \(\frac{1}{4}\)
assertEquals(.5,
1:4            --> returns \(\frac{1}{4}\)
Evaluator.getNumberResult("((((1 / 2) / 1) / 1) / 1) / 1", exerciseVariableMap, fillInVariableMap),
0.0);
}


@Test
==== Benutzung mit Variablen ====
public void testDivisionWithInputCharacter() {
divide([var=a], [var=b])
OMA result = Evaluator.evaluate("6 / a", exerciseVariableMap, fillInVariableMap).getOMA();
divide(1, [var=b])
assertEquals("<OMA><OMS name=\"divide\" cd=\"arith1\"/><OMI>6</OMI><OMV name=\"a\"/></OMA>", result.toString());
divide([var=a], 4)
}


@Test(expected = FunctionInvalidArgumentTypeException.class)
[var=a]:[var=b]
public void testDivisionWithWrongInputString() {
1:[var=b]
Evaluator.getNumberResult("6 / 'aabcd'", exerciseVariableMap, fillInVariableMap);
[var=a]:4
fail();
}


@Test(expected = UndefinedExerciseVariableException.class)
==== Benutzung mit studentischen Eingaben ====
public void testDivisionWithMissingExcerciseVariable() {
'''Jack2:'''
Evaluator.getNumberResult("[var=j] / 2", exerciseVariableMap, fillInVariableMap);
divide([pos=1], [pos=1])
fail();
divide(1, [pos=1])
}
divide([pos=1], 4)
[pos=1]:[pos=1]
1:[pos=1]
[pos=1]:4


@Test(expected = UndefinedFillInVariableException.class)
'''Jack3:'''
public void testDivisionWithMissingInput() {
divide([input=field1], [input=field1])
Evaluator.getNumberResult("[pos=42] / 2", exerciseVariableMap, fillInVariableMap);
divide(1, [input=field1])
fail();
divide([input=field1], 4)
}
divide([input=field1], [var=a])
</syntaxhighlight>
[input=field1]:[input=field1]
1:[input=field1]
[input=field1]:4
[input=field1]:[var=a]


===Hinweise===
===Hinweise===
* Das Ergebnis lässt sich mit [[equal]] ("==") vergleichen.
* Das Ergebnis lässt sich mit [[equal]] ("==") vergleichen.
* Nicht zu verwechseln mit der Funktion [[Rational]]. Im Gegensatz zu [[Rational]] wird der Bruch mit Geteiltzeichen in der Plain-Umgebung für Zeichenketten und LaTeX ausgegeben.
* Wenn Variablen genutzt werden muss darauf geachtet werden, dass diese die Voraussetzung erfüllen.
* Wenn die Eingabe der Studierenden genutzt wird muss auch hier darauf geachtet werden, dass die Voraussetzungen erfüllt sind und ob diese an der Stelle genutzt werden können.


[[Kategorie:Evaluatorfunktion]]
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Kategorie:Operator]][[Kategorie:JACK2]][[Kategorie:JACK3]]

Aktuelle Version vom 22. Mai 2024, 09:55 Uhr

Zugehörige Evaluatoren

  • MathEvaluator
  • ChemEvaluator

Beschreibung

Bei der Division wird die eine Zahl durch die andere Zahl geteilt und soweit wie möglich gekürzt.

Dabei wird nicht mehr automatisch gerundet. Soll der Bruch als Dezimalzahl ausgegeben werden, kann die Funktion round() genutzt werden.

Syntax

a:b
divide(a,b)

Parameter

Return Value

  • Gibt eine Ganzzahl oder einen Bruch zurück

Es wird soweit wie möglich die Eingabe gekürzt.

Beispiele

In Plain-Umgebung: 

1:4    -->  returns 1:4 in Zeichenketten, \(1 \div 4\) in LaTeX

divide(1, 4)    -->  returns 1:4 in Zeichenketten, \(1 \div 4\) in LaTeX

Standardfälle

Jack2:
divide(1,4)    --> returns 0,25
1:4            --> return 0,25

Jack3:
divide(1,4)    --> returns \(\frac{1}{4}\)
1:4            --> returns \(\frac{1}{4}\)

Benutzung mit Variablen

divide([var=a], [var=b])
divide(1, [var=b])
divide([var=a], 4)

[var=a]:[var=b]
1:[var=b]
[var=a]:4

Benutzung mit studentischen Eingaben

Jack2:
divide([pos=1], [pos=1])
divide(1, [pos=1])
divide([pos=1], 4)

[pos=1]:[pos=1]
1:[pos=1]
[pos=1]:4

Jack3:
divide([input=field1], [input=field1])
divide(1, [input=field1])
divide([input=field1], 4)
divide([input=field1], [var=a])

[input=field1]:[input=field1]
1:[input=field1]
[input=field1]:4
[input=field1]:[var=a]

Hinweise

  • Das Ergebnis lässt sich mit equal ("==") vergleichen.
  • Nicht zu verwechseln mit der Funktion Rational. Im Gegensatz zu Rational wird der Bruch mit Geteiltzeichen in der Plain-Umgebung für Zeichenketten und LaTeX ausgegeben.
  • Wenn Variablen genutzt werden muss darauf geachtet werden, dass diese die Voraussetzung erfüllen.
  • Wenn die Eingabe der Studierenden genutzt wird muss auch hier darauf geachtet werden, dass die Voraussetzungen erfüllt sind und ob diese an der Stelle genutzt werden können.
Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=Divide&oldid=10953“