Add 4 new rounding modes to round() function

Author: jorgsowa

NEWS

@@ -25,6 +25,8 @@ Standard:
   . Partly fix GH-12143 (Incorrect round() result for 0.49999999999999994).
     (timwolla)
   . Fix GH-12252 (round(): Validate the rounding mode). (timwolla)
+  . Added 4 new rounding modes to the round(). (Jorg Sowa)
+
 
 XSL:
   . Implement request #64137 (XSLTProcessor::setParameter() should allow both

ext/standard/basic_functions.stub.php

@@ -375,6 +375,26 @@
  * @cvalue PHP_ROUND_HALF_ODD
  */
 const PHP_ROUND_HALF_ODD = UNKNOWN;
+/**
+ * @var int
+ * @cvalue PHP_ROUND_CEILING
+ */
+const PHP_ROUND_CEILING = UNKNOWN;
+/**
+ * @var int
+ * @cvalue PHP_ROUND_FLOOR
+ */
+const PHP_ROUND_FLOOR = UNKNOWN;
+/**
+ * @var int
+ * @cvalue PHP_ROUND_TOWARD_ZERO
+ */
+const PHP_ROUND_TOWARD_ZERO = UNKNOWN;
+/**
+ * @var int
+ * @cvalue PHP_ROUND_AWAY_FROM_ZERO
+ */
+const PHP_ROUND_AWAY_FROM_ZERO = UNKNOWN;
 
 /* crypt.c */
 

ext/standard/basic_functions_arginfo.h

@@ -101,10 +101,10 @@ static inline double php_round_helper(double value, int mode) {
 	 * the absolute value of the fractional part (which will not result
 	 * in branches in the assembly) to make the following cases simpler.
 	 */
-	fractional = fabs(modf(value, &integral));
 
 	switch (mode) {
 		case PHP_ROUND_HALF_UP:
+			fractional = fabs(modf(value, &integral));
 			if (fractional >= 0.5) {
 				/* We must increase the magnitude of the integral part
 				 * (rounding up / towards infinity). copysign(1.0, integral)
@@ -120,13 +120,35 @@ static inline double php_round_helper(double value, int mode) {
 			return integral;
 
 		case PHP_ROUND_HALF_DOWN:
+			fractional = fabs(modf(value, &integral));
 			if (fractional > 0.5) {
 				return integral + copysign(1.0, integral);
 			}
 
 			return integral;
 
+		case PHP_ROUND_CEILING:
+			return ceil(value);
+
+		case PHP_ROUND_FLOOR:
+			return floor(value);
+
+		case PHP_ROUND_TOWARD_ZERO:
+			if (value >= 0.0) {
+				return floor(value);
+			} else {
+				return = ceil(value);
+			}
+
+		case PHP_ROUND_AWAY_FROM_ZERO:
+			if (value >= 0.0) {
+				return = ceil(value);
+			} else {
+				return = floor(value);
+			}
+
 		case PHP_ROUND_HALF_EVEN:
+			fractional = fabs(modf(value, &integral));
 			if (fractional > 0.5) {
 				return integral + copysign(1.0, integral);
 			}
@@ -143,7 +165,9 @@ static inline double php_round_helper(double value, int mode) {
 			}
 
 			return integral;
+
 		case PHP_ROUND_HALF_ODD:
+			fractional = fabs(modf(value, &integral));
 			if (fractional > 0.5) {
 				return integral + copysign(1.0, integral);
 			}
@@ -157,6 +181,7 @@ static inline double php_round_helper(double value, int mode) {
 			}
 
 			return integral;
+
 		EMPTY_SWITCH_DEFAULT_CASE();
 	}
 }
@@ -258,16 +283,16 @@ PHP_FUNCTION(abs)
 		Z_PARAM_NUMBER(value)
 	ZEND_PARSE_PARAMETERS_END();
 
-	switch (Z_TYPE_P(value)) {
-		case IS_LONG:
-			if (UNEXPECTED(Z_LVAL_P(value) == ZEND_LONG_MIN)) {
-				RETURN_DOUBLE(-(double)ZEND_LONG_MIN);
-			} else {
-				RETURN_LONG(Z_LVAL_P(value) < 0 ? -Z_LVAL_P(value) : Z_LVAL_P(value));
-			}
-		case IS_DOUBLE:
-			RETURN_DOUBLE(fabs(Z_DVAL_P(value)));
-		EMPTY_SWITCH_DEFAULT_CASE();
+	if (Z_TYPE_P(value) == IS_DOUBLE) {
+		RETURN_DOUBLE(fabs(Z_DVAL_P(value)));
+	} else if (Z_TYPE_P(value) == IS_LONG) {
+		if (Z_LVAL_P(value) == ZEND_LONG_MIN) {
+			RETURN_DOUBLE(-(double)ZEND_LONG_MIN);
+		} else {
+			RETURN_LONG(Z_LVAL_P(value) < 0 ? -Z_LVAL_P(value) : Z_LVAL_P(value));
+		}
+	} else {
+		ZEND_ASSERT(0 && "Unexpected type");
 	}
 }
 /* }}} */
@@ -281,12 +306,12 @@ PHP_FUNCTION(ceil)
 		Z_PARAM_NUMBER(value)
 	ZEND_PARSE_PARAMETERS_END();
 
-	switch (Z_TYPE_P(value)) {
-		case IS_LONG:
-			RETURN_DOUBLE(zval_get_double(value));
-		case IS_DOUBLE:
-			RETURN_DOUBLE(ceil(Z_DVAL_P(value)));
-		EMPTY_SWITCH_DEFAULT_CASE();
+	if (Z_TYPE_P(value) == IS_DOUBLE) {
+		RETURN_DOUBLE(ceil(Z_DVAL_P(value)));
+	} else if (Z_TYPE_P(value) == IS_LONG) {
+		RETURN_DOUBLE(zval_get_double(value));
+	} else {
+		ZEND_ASSERT(0 && "Unexpected type");
 	}
 }
 /* }}} */
@@ -300,12 +325,12 @@ PHP_FUNCTION(floor)
 		Z_PARAM_NUMBER(value)
 	ZEND_PARSE_PARAMETERS_END();
 
-	switch (Z_TYPE_P(value)) {
-		case IS_LONG:
-			RETURN_DOUBLE(zval_get_double(value));
-		case IS_DOUBLE:
-			RETURN_DOUBLE(floor(Z_DVAL_P(value)));
-		EMPTY_SWITCH_DEFAULT_CASE();
+	if (Z_TYPE_P(value) == IS_DOUBLE) {
+		RETURN_DOUBLE(floor(Z_DVAL_P(value)));
+	} else if (Z_TYPE_P(value) == IS_LONG) {
+		RETURN_DOUBLE(zval_get_double(value));
+	} else {
+		ZEND_ASSERT(0 && "Unexpected type");
 	}
 }
 /* }}} */
@@ -317,6 +342,7 @@ PHP_FUNCTION(round)
 	int places = 0;
 	zend_long precision = 0;
 	zend_long mode = PHP_ROUND_HALF_UP;
+	double return_val;
 
 	ZEND_PARSE_PARAMETERS_START(1, 3)
 		Z_PARAM_NUMBER(value)
@@ -333,29 +359,21 @@ PHP_FUNCTION(round)
 		}
 	}
 
-	switch (mode) {
-		case PHP_ROUND_HALF_UP:
-		case PHP_ROUND_HALF_DOWN:
-		case PHP_ROUND_HALF_EVEN:
-		case PHP_ROUND_HALF_ODD:
-			break;
-		default:
-			zend_argument_value_error(3, "must be a valid rounding mode (PHP_ROUND_*)");
-			RETURN_THROWS();
-	}
-
 	switch (Z_TYPE_P(value)) {
 		case IS_LONG:
 			/* Simple case - long that doesn't need to be rounded. */
 			if (places >= 0) {
-				RETURN_DOUBLE(zval_get_double(value));
+				RETURN_DOUBLE((double) Z_LVAL_P(value));
 			}
 			ZEND_FALLTHROUGH;
 
 		case IS_DOUBLE:
-			RETURN_DOUBLE(_php_math_round(zval_get_double(value), (int)places, (int)mode));
+			return_val = (Z_TYPE_P(value) == IS_LONG) ? (double)Z_LVAL_P(value) : Z_DVAL_P(value);
+			return_val = _php_math_round(return_val, (int)places, (int)mode);
+			RETURN_DOUBLE(return_val);
+			break;
 
-		EMPTY_SWITCH_DEFAULT_CASE();
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
 }
 /* }}} */

ext/standard/math.c

@@ -103,7 +103,7 @@ PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base);
 #endif
 
 #ifndef PHP_ROUND_HALF_DOWN
-#define PHP_ROUND_HALF_DOWN      0x02    /* Down == towards zero */
+#define PHP_ROUND_HALF_DOWN      0x02    /* Arithmetic rounding, down == towards zero */
 #endif
 
 #ifndef PHP_ROUND_HALF_EVEN
@@ -114,4 +114,20 @@ PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base);
 #define PHP_ROUND_HALF_ODD       0x04
 #endif
 
+#ifndef PHP_ROUND_CEILING
+#define PHP_ROUND_CEILING        0x05
+#endif
+
+#ifndef PHP_ROUND_FLOOR
+#define PHP_ROUND_FLOOR          0x06
+#endif
+
+#ifndef PHP_ROUND_TOWARD_ZERO
+#define PHP_ROUND_TOWARD_ZERO    0x07
+#endif
+
+#ifndef PHP_ROUND_AWAY_FROM_ZERO
+#define PHP_ROUND_AWAY_FROM_ZERO 0x08
+#endif
+
 #endif /* PHP_MATH_H */