Correct EVEN? and ODD? for decimals.

Optimize and simplify integer ADD.
Optimize and simplify integer SUBTRACT.
Optimize and simplify integer MULTIPLY.
Generalize integer DIVIDE.
Generalize integer NEGATE.
Generalize and optimize integer ABS.

Author: ladislav

src/core/t-decimal.c

@@ -45,22 +45,22 @@ static char *gcvt(double value, int digits, char *buffer)
 
 /*
 	Purpose: {defines the almost_equal comparison function}
-	Properties: {    
+	Properties: {
 		since floating point numbers are ordered and there is only
 		a finite quantity of floating point numbers, it is possible
 		to assign an ordinal (integer) number to any floating point number so,
 		that the ordinal numbers of neighbors differ by one
-		
+
 		the function compares floating point numbers based on
 		the difference of their ordinal numbers in the ordering
 		of floating point numbers
-		
+
 		difference of 0 means exact equality, difference of 1 means, that
 		the numbers are neighbors.
 	}
 	Advantages: {
 		the function detects approximate equality.
-		
+
 		the function is more strict in the zero neighborhood than
 		absolute-error-based approaches
 
@@ -69,15 +69,15 @@ static char *gcvt(double value, int digits, char *buffer)
 		meaning that neighbors are deemed equal, max_diff = 10 meaning, that
 		the numbers are deemed equal if at most 9
 		distinct floating point numbers can be found between them
-		
+
 		the max_diff value may be one of the system options specified in
 		the system/options object allowing users to exactly define the
 		strictness of equality checks
 	}
 	Differences: {
 		The approximate comparison currently used in R3 corresponds to the
 		almost_equal function using max_diff = 10 (according to my tests).
-		
+
 		The main differences between the currently used comparison and the
 		one based on the ordinal number comparison are:
 		-   the max_diff parameter can be adjusted, allowing
@@ -106,7 +106,7 @@ REBOOL almost_equal(REBDEC a, REBDEC b, REBCNT max_diff) {
 
 	int_diff = ua.i - ub.i;
 	if (int_diff < 0) int_diff = -int_diff;
-	
+
 	return ((REBU64) int_diff <= max_diff);
 }
 
@@ -316,13 +316,15 @@ REBOOL almost_equal(REBDEC a, REBDEC b, REBCNT max_diff) {
 		case A_NEGATE:
 			d1 = -d1;
 			goto setDec;
+
 		case A_ABSOLUTE:
 			if (d1 < 0) d1 = -d1;
 			goto setDec;
+
 		case A_EVENQ:
 		case A_ODDQ:
 			d1 = fabs(fmod(d1, 2.0));
-			DECIDE((action != A_EVENQ) != ((d1 < 0.5) || (d1 >= 1.5)));
+			DECIDE((action == A_EVENQ) == (d1 < -1.5 || d1 > 1.5 || (d1 > -0.5 && d1 < 0.5)));
 
 		case A_MAKE:
 		case A_TO:
@@ -341,23 +343,23 @@ REBOOL almost_equal(REBDEC a, REBDEC b, REBCNT max_diff) {
 			case REB_PERCENT:
 				d1 = VAL_DECIMAL(val);
 				goto setDec;
-			
+
 			case REB_INTEGER:
 				d1 = (REBDEC)VAL_INT64(val);
 				goto setDec;
-			
+
 			case REB_MONEY:
 				d1 = deci_to_decimal(VAL_DECI(val));
 				goto setDec;
-			
+
 			case REB_LOGIC:
 				d1 = VAL_LOGIC(val) ? 1.0 : 0.0;
 				goto setDec;
-			
+
 			case REB_CHAR:
 				d1 = (REBDEC)VAL_CHAR(val);
 				goto setDec;
-			
+
 			case REB_TIME:
 				d1 = VAL_TIME(val) * NANO;
 				break;
@@ -374,12 +376,12 @@ REBOOL almost_equal(REBDEC a, REBDEC b, REBCNT max_diff) {
 				}
 				Trap_Make(type, val);
 			}
-			
+
 			case REB_BINARY:
 				Binary_To_Decimal(val, D_RET);
 				d1 = VAL_DECIMAL(D_RET);
 				break;
-			
+
 #ifdef removed
 //			case REB_ISSUE:
 			{

src/core/t-integer.c

@@ -55,10 +55,8 @@
 	REBI64 arg;
 	REBINT n;
 
-	REBU64 p, a, b; // for overflow detection
-	REBCNT a1, a0, b1, b0;
+	REBU64 a1, a0, b1, b0;
 	REBFLG sgn;
-	REBI64 anum;
 
 	num = VAL_INT64(val);
 
@@ -110,46 +108,62 @@
 	switch (action) {
 
 	case A_ADD:
-		anum = (REBU64)num + (REBU64)arg;
-		if (
-			((num < 0) == (arg < 0)) && ((num < 0) != (anum < 0))
-		) Trap0(RE_OVERFLOW);
-		num = anum;
+		if(num >= 0) {
+			if(arg > MAX_I64 - num)
+				Trap0(RE_OVERFLOW);
+		} else {
+			if(arg < MIN_I64 - num)
+				Trap0(RE_OVERFLOW);
+		}
+		num += arg;
 		break;
 
 	case A_SUBTRACT:
-		anum = (REBU64)num - (REBU64)arg;
-		if (
-			((num < 0) != (arg < 0)) && ((num < 0) != (anum < 0))
-		) Trap0(RE_OVERFLOW);
-		num = anum;
+		if(arg >= 0) {
+			if(num < MIN_I64 + arg)
+				Trap0(RE_OVERFLOW);
+		} else {
+			if(num > MAX_I64 + arg)
+				Trap0(RE_OVERFLOW);
+		}
+		num -= arg;
 		break;
 
 	case A_MULTIPLY:
-		a = num;
-		sgn = (num < 0);
-		if (sgn) a = -a;
-		b = arg;
-		if (arg < 0) {
+		// handle signs
+		sgn = num < 0;
+		if(sgn)
+			num = -(REBU64) num;
+		if(arg < 0) {
 			sgn = !sgn;
-			b = -b;
+			arg = -(REBU64) arg;
 		}
-		p = a * b;
-		a1 = a>>32;
-		a0 = a;
-		b1 = b>>32;
-		b0 = b;
-		if (
-			(a1 && b1)
-			|| ((REBU64)a0 * b1 + (REBU64)a1 * b0 > p >> 32)
-			|| ((p > (REBU64)MAX_I64) && (!sgn || (p > -(REBU64)MIN_I64)))
-		) Trap0(RE_OVERFLOW);
-		num = sgn ? -p : p;
+		// subdivide the factors
+		a1 = (REBU64) num >> 32;
+		b1 = (REBU64) arg >> 32;
+		a0 = (REBU64) num & 0xFFFFFFFFu;
+		b0 = (REBU64) arg & 0xFFFFFFFFu;
+		// multiply the parts
+		if(!a1)
+			num = b1 * a0;
+		else if(!b1)
+			num = a1 * b0;
+		else
+			Trap0(RE_OVERFLOW);
+		if((REBU64) num > (REBU64) MIN_I64 >> 32)
+			Trap0(RE_OVERFLOW);
+		num = ((REBU64) num << 32) + a0 * b0;
+		if(sgn) {
+			if((REBU64) num > (REBU64) MIN_I64)
+				Trap0(RE_OVERFLOW);
+			num = -(REBU64) num;
+		} else if((REBU64) num > (REBU64) MAX_I64)
+			Trap0(RE_OVERFLOW);
 		break;
 
 	case A_DIVIDE:
 		if (arg == 0) Trap0(RE_ZERO_DIVIDE);
-		if (num == MIN_I64 && arg == -1) Trap0(RE_OVERFLOW);
+		if (num < - MAX_I64 && arg == -1) Trap0(RE_OVERFLOW);
 		if (num % arg == 0) {
 			num = num / arg;
 			break;
@@ -171,15 +185,18 @@
 	case A_XOR: num ^= arg; break;
 
 	case A_NEGATE:
-		if (num == MIN_I64) Trap0(RE_OVERFLOW);
+		if (num < - MAX_I64) Trap0(RE_OVERFLOW);
 		num = -num;
 		break;
 
 	case A_COMPLEMENT: num = ~num; break;
 
-	case A_ABSOLUTE: 
-		if (num == MIN_I64) Trap0(RE_OVERFLOW);
-		if (num < 0) num = -num;
+	case A_ABSOLUTE:
+		if(num < 0) {
+			if (num < - MAX_I64)
+				Trap0(RE_OVERFLOW);
+			num = -num;
+		}
 		break;
 
 	case A_EVENQ: num = ~num;