Plus: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
 
(17 dazwischenliegende Versionen von 6 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
===Zugehörige Evaluatoren===
*'''MathEvaluator'''
*'''ChemEvaluator'''
===Beschreibung===
===Beschreibung===
Bei der ''Addition'' werden zwei Zahlen miteinander addiert.
Bei der ''Addition'' werden zwei [[Objekt]]e addiert.


===Syntax===
===Syntax===
a + b
  a + b
  plus(a,b)


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


===Return Value===
===Return Value===
* Gibt eine expression zurück.
* Gibt ein [[Objekt]] zurück.
Die Rückgabe ist abhängig von der Eingabe. Dabei wird soweit wie möglich die Eingabe ausgerechnet.


===Beispiele===
===Beispiele===
  <math>3+5</math>   --> returns 8
  3 + 5    --> returns 8
 
  <math>\frac{1}{2} + \frac{3}{2}</math>    --> returns 2
  1/2 + 3/2   --> returns 2  
 
====JUnit Tests====
2 + a    --> returns 2 + a
<span class="mw-customtoggle-myDivision">[Anzeigen]</span>
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
b + c   --> returns b + c
@BeforeClass
public static void beforeTest() {
sin(x) + z    --> returns sin(x) + z
fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
cos(0) + a    --> returns 1 + a
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));
fillInVariableMap.put(3, OMConverter.toObject("<OMOBJ><OMI>3.5</OMI></OMOBJ>"));
'1' + 'Hallo'  --> returns 1Hallo
 
exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
'Hallo' + 'World'   --> returns HalloWorld
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));
exerciseVariableMap.put("c", OMConverter.toObject("<OMOBJ><OMI>3.5</OMI></OMOBJ>"));
vector(1,2) + vector(2,3)   --> returns vector(3,5)
}
 
@Test
public void testAddition1() {
assertEquals(10, Evaluator.getNumberResult("6+4", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAddition2() {
assertEquals(10.2, Evaluator.getNumberResult("7.3+2.9", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAddition3() {
assertEquals(1, Evaluator.getNumberResult("0.5 + 0.5", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAddition4() {
assertEquals(11, Evaluator.getNumberResult("0.5 + 0.5 + 10", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithNegativeNumber1() {
assertEquals(4.4, Evaluator.getNumberResult("7.3+(-2.9)", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithNegativeNumber2() {
assertEquals(-5.3, Evaluator.getNumberResult("-7.3+2", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithNegativeNumber3() {
assertEquals(-8, Evaluator.getNumberResult("-2+(-6)", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithVariables1() {
assertEquals(9, Evaluator.getNumberResult("6+[var=a]", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithVariables2() {
assertEquals(12.9, Evaluator.getNumberResult("[var=b]+2.9", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithVariables3() {
assertEquals(10.5, Evaluator.getNumberResult("[var=c]+7", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithInput1() {
assertEquals(9, Evaluator.getNumberResult("6+[pos=1]", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithInput2() {
assertEquals(12.9, Evaluator.getNumberResult("[pos=2]+2.9", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithInput3() {
assertEquals(10.5, Evaluator.getNumberResult("[pos=3]+7", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithEncapsulation1() {
assertEquals(3, Evaluator.getNumberResult("1 + (1 + 1)", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithEncapsulation2() {
assertEquals(4, Evaluator.getNumberResult("1 + (1 + (1 + 1))", exerciseVariableMap, fillInVariableMap), 0.0);
}
 
@Test
public void testAdditionWithEncapsulation3() {
assertEquals(6,
Evaluator.getNumberResult("1 + (1 + (1 + (1 + (1 + 1))))", exerciseVariableMap, fillInVariableMap),
0.0);
}
 
@Test
public void testAdditionWithEncapsulation4() {
assertEquals(6,
Evaluator.getNumberResult("((((1 + 1) + 1) + 1) + 1) + 1", exerciseVariableMap, fillInVariableMap),
0.0);
}
 
@Test
public void testAdditionWithInputCharacter() {
OMA result = Evaluator.evaluate("6 + a", exerciseVariableMap, fillInVariableMap).getOMA();
assertEquals("<OMA><OMS name=\"plus\" cd=\"arith1\"/><OMI>6</OMI><OMV name=\"a\"/></OMA>", result.toString());
}
 
@Test
public void testAdditionWithInputCharAsString() {
OMA result = Evaluator.evaluate("6 + 'a'", exerciseVariableMap, fillInVariableMap).getOMA();
assertEquals("<OMA><OMS name=\"plus\" cd=\"arith1\"/><OMI>6</OMI><OMV name=\"a\"/></OMA>", result.toString());
}
 
@Test(expected=FunctionInvalidArgumentTypeException.class)
public void testAdditionWithWrongInputString() {
OMA result = Evaluator.evaluate("6 + 'abcd'", exerciseVariableMap, fillInVariableMap).getOMA();
assertEquals("<OMA><OMS name=\"plus\" cd=\"arith1\"/><OMI>6</OMI><OMV name=\"a\"/></OMA>", result.toString());
fail();
}
 
@Test(expected = UndefinedExerciseVariableException.class)
public void testAdditionWithMissingExcerciseVariable() {
Evaluator.getNumberResult("[var=j] + 1", exerciseVariableMap, fillInVariableMap);
fail();
}
 
@Test(expected = UndefinedFillInVariableException.class)
public void testAdditionWithMissingInput() {
Evaluator.getNumberResult("[pos=42] + 1", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>


===Hinweise===
===Hinweise===
* Mit [[equal]] ("==") lässt sich das Ergebnis anschließend vergleichen.
* Mit [[equal]] ("==") lässt sich das Ergebnis anschließend ebenfalls mit einem anderem [[Objekt]] vergleichen.
* Diese Funktion ist ein binärer Operator.


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

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

Zugehörige Evaluatoren

  • MathEvaluator
  • ChemEvaluator

Beschreibung

Bei der Addition werden zwei Objekte addiert.

Syntax

 a + b
 plus(a,b)

Parameter

Return Value

Die Rückgabe ist abhängig von der Eingabe. Dabei wird soweit wie möglich die Eingabe ausgerechnet.

Beispiele

3 + 5    --> returns 8

1/2 + 3/2   --> returns 2 

2 + a    --> returns 2 + a

b + c    --> returns b + c

sin(x) + z    --> returns sin(x) + z

cos(0) + a    --> returns 1 + a

'1' + 'Hallo'   --> returns 1Hallo

'Hallo' + 'World'   --> returns HalloWorld

vector(1,2) + vector(2,3)   --> returns vector(3,5)

Hinweise

  • Mit equal ("==") lässt sich das Ergebnis anschließend ebenfalls mit einem anderem Objekt vergleichen.
  • Diese Funktion ist ein binärer Operator.
Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=Plus&oldid=10949“