IEEERemainder: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
KKeine Bearbeitungszusammenfassung
 
(20 dazwischenliegende Versionen von 4 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion im JACK3 System.}}
===Zugehörige Evaluatoren===
*'''MathEvaluator'''
=== Beschreibung ===
=== Beschreibung ===
 
Die Funktion ''iEEERemainder'' berechnet die Remainder-Operation zweier Argumente, wie es in dem IEEE 745 Standard beschrieben ist [https://de.wikipedia.org/wiki/IEEE_754#Aritmetik_und_Quadratwurzel]. Die Funktion erwartet zwei Zahlen und gibt das Ergebnis von
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.
f1-(f2* Math.Round(f1/f2))
zurück.


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


=== Parameter ===
=== Parameter ===
Zeile 11: Zeile 17:


=== Return Value ===
=== Return Value ===
*Gibt den Rest-Wert zurück, wenn f1 durch f2 geteilt wird
* Gibt das gerundete Ergebnis von f1-(f2*Q) zurück. Q ist dabei das gerundete Ergebnis von f1/f2. '''Hinweis''': Wenn f1/f2 genau zwischen zwei ganzen Zahlen liegt, wird die gerade ganze Zahl zurückgegeben.
* Wenn f1-(f2*Q) gleich 0 ist, wird bei positivem f1 ''+0'' und bei negativem f1 ''-0'' zurückgegeben.
* Wenn f2 gleich 0 ist, wird NaN zurückgegeben.


=== Beispiele ===
===Unterschied zu Modulo===
==== Standardfälle ====
Beide geben den Rest nach der Division zurück, verwenden aber unterschiedliche Formeln:
IEEEremainder(4,2)  --> returns 0
IEEEremainder(3,2)  --> returns -1


==== Benutzung mit Variablen ====
iEEERemainder = dividend -(divisor * Math.Round(dividend / divisor))
IEEEremainder([pos=1],[pos=2])
IEEEremainder([var=a],[var=b])


====JUnit Tests====
Modulo = (Math.Abs(dividend) - (Math.Abs(divisor) * (Math.Floor(Math.Abs(dividend) / Math.Abs(divisor))))) * Math.Sign(dividend)
<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>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>"));
Beispiel:
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>20</OMI></OMOBJ>"));
exerciseVariableMap.put("c", OMConverter.toObject("<OMOBJ><OMI>-10</OMI></OMOBJ>"));
}


@Test
3/2    iEEERemainder-->returns -1    Modulo-->returns 1
public void testIEEERemainder1() {
11/3  iEEERemainder-->returns -1   Modulo-->returns 2
assertEquals(-1, Evaluator.getNumberResult("IEEEremainder(3, 2)", exerciseVariableMap, fillInVariableMap), 0);
28/5  iEEERemainder-->returns -2    Modulo-->returns 3
}


@Test
=== Beispiele ===
public void testIEEERemainder2() {
==== Standardfälle ====
assertEquals(0, Evaluator.getNumberResult("IEEEremainder(4, 2)", exerciseVariableMap, fillInVariableMap), 0);
iEEERemainder(4,2)   --> returns 0
}
iEEERemainder(3,2)   --> returns -1
iEEERemainder(27,4) --> returns -1
iEEERemainder(17.8,4) --> returns 1.8


@Test
==== Benutzung mit Variablen ====
public void testIEEERemainder3() {
iEEERemainder([var=a],[var=b])
assertEquals(1, Evaluator.getNumberResult("IEEEremainder(10, 3)", exerciseVariableMap, fillInVariableMap), 0);
}
==== Benutzung mit studentischen Eingaben ====
 
'''Jack2:'''
@Test
iEEERemainder([pos=1],[pos=2])
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)
'''Jack3:'''
public void testIEEERemainderAtZero() {
iEEERemainder([input=field1],[input=field2])
Evaluator.getNumberResult("IEEEremainder(5, 0)", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>


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

Aktuelle Version vom 17. April 2024, 07:56 Uhr

Diese Seite beinhaltet eine Evaluator-Funktion im JACK3 System.

Zugehörige Evaluatoren

  • MathEvaluator

Beschreibung

Die Funktion iEEERemainder berechnet die Remainder-Operation zweier Argumente, wie es in dem IEEE 745 Standard beschrieben ist [1]. Die Funktion erwartet zwei Zahlen und gibt das Ergebnis von 

f1-(f2* Math.Round(f1/f2))

zurück.

Syntax

iEEERemainder(Gleitkommazahl f1, Gleitkommazahl f2)

Parameter

  • f1 - Zähler
  • f2 - Nenner

Return Value

  • Gibt das gerundete Ergebnis von f1-(f2*Q) zurück. Q ist dabei das gerundete Ergebnis von f1/f2. Hinweis: Wenn f1/f2 genau zwischen zwei ganzen Zahlen liegt, wird die gerade ganze Zahl zurückgegeben.
  • Wenn f1-(f2*Q) gleich 0 ist, wird bei positivem f1 +0 und bei negativem f1 -0 zurückgegeben.
  • Wenn f2 gleich 0 ist, wird NaN zurückgegeben.

Unterschied zu Modulo

Beide geben den Rest nach der Division zurück, verwenden aber unterschiedliche Formeln: 

iEEERemainder = dividend -(divisor * Math.Round(dividend / divisor))

Modulo = (Math.Abs(dividend) - (Math.Abs(divisor) * (Math.Floor(Math.Abs(dividend) / Math.Abs(divisor))))) * Math.Sign(dividend)

Beispiel: 

3/2    iEEERemainder-->returns -1    Modulo-->returns 1
11/3   iEEERemainder-->returns -1    Modulo-->returns 2
28/5   iEEERemainder-->returns -2    Modulo-->returns 3

Beispiele

Standardfälle

iEEERemainder(4,2)   --> returns 0
iEEERemainder(3,2)   --> returns -1
iEEERemainder(27,4)  --> returns -1
iEEERemainder(17.8,4)  --> returns 1.8

Benutzung mit Variablen

iEEERemainder([var=a],[var=b])

Benutzung mit studentischen Eingaben

Jack2:
iEEERemainder([pos=1],[pos=2])

Jack3:
iEEERemainder([input=field1],[input=field2])
Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=IEEERemainder&oldid=10582“