{"id":61,"date":"2019-08-30T19:30:32","date_gmt":"2019-08-30T19:30:32","guid":{"rendered":"https:\/\/tutorialio.com\/?p=61"},"modified":"2019-08-30T19:30:32","modified_gmt":"2019-08-30T19:30:32","slug":"numerical-functions-in-php","status":"publish","type":"post","link":"https:\/\/hellonitish.com\/blog\/numerical-functions-in-php\/","title":{"rendered":"Numerical Functions in PHP"},"content":{"rendered":"\n\n\n\n\n\n\n\n\n\n\n\n\n
Numerical Functions in PHP<\/caption>\n<\/caption>\n
Function Name<\/th>\nFunction Description<\/th>\n<\/tr>\n
abs()<\/a><\/td>\nAbsolute value<\/td>\n<\/tr>\n
ceil()<\/a><\/td>\nRound fractions up<\/td>\n<\/tr>\n
floor()<\/a><\/td>\nRound fractions down<\/td>\n<\/tr>\n
fmod()<\/a><\/td>\nReturns the floating point remainder (modulo) of the division of the arguments<\/td>\n<\/tr>\n
is_finite()<\/a><\/td>\nFinds whether a value is a legal finite number<\/td>\n<\/tr>\n
is_infinite()<\/a><\/td>\nFinds whether a value is infinite<\/td>\n<\/tr>\n
is_nan()<\/a><\/td>\nFinds whether a value is not a number<\/td>\n<\/tr>\n
max()<\/a><\/td>\nFind highest value<\/td>\n<\/tr>\n
min()<\/a><\/td>\nFind lowest value<\/td>\n<\/tr>\n
round()<\/a><\/td>\nRounds a float<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

PHP abs()<\/code> Function<\/h2>\n

PHP abs()<\/code> Usage<\/h3>\n

The PHP abs()<\/code><\/code> function will give you the absolute value of number<\/code>.<\/p>\n

PHP abs()<\/code> Syntax<\/h3>\n
 abs ( mixed $number ) : number<\/code><\/pre>\n
PHP abs()<\/code> Parameters<\/h3>\n
    \n
  1. \n
    number<\/code> \u2014 The numeric value to process <\/p>\n<\/li>\n<\/ol>\n
    PHP abs()<\/code> Return Value<\/h3>\n
    The PHP abs()<\/code> function returns type is also float, otherwise it is integer (as float usually has a bigger value range than integer).<\/p>\n
    PHP abs()<\/code> Working Examples<\/h3>\n
    1. abs() example<\/h4>\n
    <?php\necho abs(-4.2); \/\/ 4.2 (double\/float)\necho abs(5);    \/\/ 5 (integer)\necho abs(-5);   \/\/ 5 (integer)\n?><\/code><\/pre>\n
    PHP ceil()<\/code> Function<\/h2>\n
    PHP ceil()<\/code> Usage<\/h3>\n
    The PHP ceil()<\/code><\/code> function will give you the next highest integer value by rounding up value<\/code> if necessary.<\/p>\n
    PHP ceil()<\/code> Syntax<\/h3>\n
     ceil ( float $value ) : float<\/code><\/pre>\n
    PHP ceil()<\/code> Parameters<\/h3>\n
      \n
    1. \n
      value<\/code> \u2014 The value to round <\/p>\n<\/li>\n<\/ol>\n
      PHP ceil()<\/code> Return Value<\/h3>\n
      The PHP ceil()<\/code> function returns value of ceil()<\/code> is still of type float as the value range of float is usually bigger than that of integer.<\/p>\n
      PHP ceil()<\/code> Working Examples<\/h3>\n
      1. ceil() example<\/h4>\n
      <?php\necho ceil(4.3);    \/\/ 5\necho ceil(9.999);  \/\/ 10\necho ceil(-3.14);  \/\/ -3\n?><\/code><\/pre>\n
      Additional Tips from Fellow Developers<\/h3>\n
      Contributed By: Scott Weaver \/ scottmweaver * gmail<\/p>\n
      I needed this and couldn't find it so I thought someone else wouldn't have to look through a bunch of Google results-\n
      <?php\n\/\/ duplicates m$ excel's ceiling function\nif( !function_exists('ceiling') )\n{\n    function ceiling($number, $significance = 1)\n    {\n        return ( is_numeric($number) && is_numeric($significance) ) ? (ceil($number\/$significance)*$significance) : false;\n    }\n}\necho ceiling(0, 1000);     \/\/ 0\necho ceiling(1, 1);        \/\/ 1000\necho ceiling(1001, 1000);  \/\/ 2000\necho ceiling(1.27, 0.05);  \/\/ 1.30\n?>
      <\/pre>\n
      <\/code><\/p>\n
      Contributed By: eep2004<\/p>\n
      Caution!\n
      <?php\n$value = 77.4;\necho ceil($value * 100) \/ 100;         \/\/ 77.41 - WRONG!\necho ceil(round($value * 100)) \/ 100;  \/\/ 77.4 - OK!<\/pre>\n
      <\/code><\/p>\n
      Contributed By: steve_phpnet \/\/ nanovox \\\\ com<\/p>\n
      I couldn't find any functions to do what ceiling does while still leaving I specified number of decimal places, so I wrote a couple functions myself.  round_up is like ceil but allows you to specify a number of decimal places.  round_out does the same, but rounds away from zero.\n
      <?php\n \/\/ round_up:\n \/\/ rounds up a float to a specified number of decimal places\n \/\/ (basically acts like ceil() but allows for decimal places)\n function round_up ($value, $places=0) {\n  if ($places < 0) { $places = 0; }\n  $mult = pow(10, $places);\n  return ceil($value * $mult) \/ $mult;\n }\n \/\/ round_out:\n \/\/ rounds a float away from zero to a specified number of decimal places\n function round_out ($value, $places=0) {\n  if ($places < 0) { $places = 0; }\n  $mult = pow(10, $places);\n  return ($value >= 0 ? ceil($value * $mult):floor($value * $mult)) \/ $mult;\n }\n echo round_up (56.77001, 2); \/\/ displays 56.78\n echo round_up (-0.453001, 4); \/\/ displays -0.453\n echo round_out (56.77001, 2); \/\/ displays 56.78\n echo round_out (-0.453001, 4); \/\/ displays -0.4531\n?>
      <\/pre>\n
      <\/code><\/p>\n
      PHP floor()<\/code> Function<\/h2>\n
      PHP floor()<\/code> Usage<\/h3>\n
      The PHP floor()<\/code><\/code> function will give you the next lowest integer value (as float) by rounding down value<\/code> if necessary.<\/p>\n
      PHP floor()<\/code> Syntax<\/h3>\n
       floor ( float $value ) : float<\/code><\/pre>\n
      PHP floor()<\/code> Parameters<\/h3>\n
        \n
      1. \n
        value<\/code> \u2014 The numeric value to round <\/p>\n<\/li>\n<\/ol>\n
        PHP floor()<\/code> Return Value<\/h3>\n
        The PHP floor()<\/code> function returns value of floor()<\/code> is still of type float because the value range of float is usually bigger than that of integer. This function return FALSE<\/code> in case of an error (e.g. passing an array).<\/p>\n
        PHP floor()<\/code> Working Examples<\/h3>\n
        1. floor() example<\/h4>\n
        <?php\necho floor(4.3);   \/\/ 4\necho floor(9.999); \/\/ 9\necho floor(-3.14); \/\/ -4\n?><\/code><\/pre>\n
        Additional Tips from Fellow Developers<\/h3>\n
        Contributed By: greene dot mc<\/p>\n
        I believe this behavior of the floor function was intended.  Note that it says \"the next lowest integer\".  -1 is \"higher\" than -1.6.  As in, -1 is logically greater than -1.6.  To go lower the floor function would go to -2 which is logically less than -1.6.\nFloor isn't trying to give you the number closest to zero, it's giving you the lowest bounding integer of a float.\nIn reply to Glen who commented:\n Glen\n01-Dec-2007 04:22\n
        <?php\n  echo floor(1.6);  \/\/ will output \"1\"\n  echo floor(-1.6); \/\/ will output \"-2\"\n?>
        \ninstead use intval (seems to work v5.1.6):\n
        <?php\n  echo intval(1.6);  \/\/ will output \"1\"\n  echo intval(-1.6); \/\/ will output \"-1\"\n?>
        <\/pre>\n
        <\/code><\/p>\n
        Contributed By: seppili_<\/p>\n
        I use this function to floor with decimals:\n
        <?php\nfunction floordec($zahl,$decimals=2){    \n     return floor($zahl*pow(10,$decimals))\/pow(10,$decimals);\n}\n?>
        <\/pre>\n
        <\/code><\/p>\n
        Contributed By: maikl<\/p>\n
        A correction to the funcion floor_dec from the user \"php is the best\".\nIf the number is 0.05999 it returns 0.59 because the zero at left position is deleted.\nI just added a '1' and after the floor or ceil call remove with a substr.\nHope it helps.\nfunction floor_dec($number,$precision = 2,$separator = '.') {\n  $numberpart=explode($separator,$number);\n  $numberpart[1]=substr_replace($numberpart[1],$separator,$precision,0);\n  if($numberpart[0]>=0) {\n    $numberpart[1]=substr(floor('1'.$numberpart[1]),1);\n  } else {\n    $numberpart[1]=substr(ceil('1'.$numberpart[1]),1);\n  }\n  $ceil_number= array($numberpart[0],$numberpart[1]);\n  return implode($separator,$ceil_number);\n}<\/pre>\n
        <\/code><\/p>\n
        Contributed By: benrr101<\/p>\n
        But, if you want the number closest to zero, you could use this:\n
        <?php\n  if($foo > 0) {\n    floor($foo);\n  } else {\n    ceil($foo);\n  }\n?>
        \n-benrr101<\/pre>\n
        <\/code><\/p>\n
        Contributed By: fragov<\/p>\n
        Have solved a \"price problem\": \n \n
        <?php \n$peny = floor($row->price*1000) - floor($row->price)*1000)\/10; \n?>
        <\/pre>\n
        <\/code><\/p>\n
        PHP fmod()<\/code> Function<\/h2>\n
        PHP fmod()<\/code> Usage<\/h3>\n
        The PHP fmod()<\/code><\/code> function will give you the floating point remainder (modulo) of the division of the arguments.<\/p>\n
        PHP fmod()<\/code> Syntax<\/h3>\n
         fmod ( float $x , float $y ) : float<\/code><\/pre>\n
        PHP fmod()<\/code> Parameters<\/h3>\n
          \n
        1. \n
          x<\/code> \u2014 The dividend <\/p>\n<\/li>\n
        2. \n
          y<\/code> \u2014 The divisor <\/p>\n<\/li>\n<\/ol>\n
          PHP fmod()<\/code> Return Value<\/h3>\n
          The PHP fmod()<\/code> function returns the floating point remainder of x<\/code>\/y<\/code><\/p>\n
          PHP fmod()<\/code> Working Examples<\/h3>\n
          1. Using fmod()<\/h4>\n
          <?php\n$x = 5.7;\n$y = 1.3;\n$r = fmod($x, $y);\n\/\/ $r equals 0.5, because 4 * 1.3 + 0.5 = 5.7\n?><\/code><\/pre>\n
          PHP is_finite()<\/code> Function<\/h2>\n
          PHP is_finite()<\/code> Usage<\/h3>\n
          The PHP is_finite()<\/code><\/code> function will finds whether a value is a legal finite number.<\/p>\n
          PHP is_finite()<\/code> Syntax<\/h3>\n
           is_finite ( float $val ) : bool<\/code><\/pre>\n
          PHP is_finite()<\/code> Parameters<\/h3>\n
            \n
          1. \n
            val<\/code> \u2014 The value to check <\/p>\n<\/li>\n<\/ol>\n
            PHP is_finite()<\/code> Return Value<\/h3>\n
            The PHP is_finite()<\/code> function returns TRUE<\/code> if val<\/code> is a legal finite number within the allowed range for a PHP float on this platform, else FALSE<\/code>.<\/p>\n
            PHP is_infinite()<\/code> Function<\/h2>\n
            PHP is_infinite()<\/code> Usage<\/h3>\n
            The PHP is_infinite()<\/code><\/code> function will give you TRUE<\/code> if val<\/code> is infinite (positive or negative), like the result of log(0)<\/strong> or any value too big to fit into a float on this platform.<\/p>\n
            PHP is_infinite()<\/code> Syntax<\/h3>\n
             is_infinite ( float $val ) : bool<\/code><\/pre>\n
            PHP is_infinite()<\/code> Parameters<\/h3>\n
              \n
            1. \n
              val<\/code> \u2014 The value to check <\/p>\n<\/li>\n<\/ol>\n
              PHP is_infinite()<\/code> Return Value<\/h3>\n
              The PHP is_infinite()<\/code> function returns TRUE<\/code> if val<\/code> is infinite, else FALSE<\/code>.<\/p>\n
              PHP is_nan()<\/code> Function<\/h2>\n
              PHP is_nan()<\/code> Usage<\/h3>\n
              The PHP is_nan()<\/code><\/code> function will checks whether val<\/code> is 'not a number', like the result of acos(1.01)<\/strong>.<\/p>\n
              PHP is_nan()<\/code> Syntax<\/h3>\n
               is_nan ( float $val ) : bool<\/code><\/pre>\n
              PHP is_nan()<\/code> Parameters<\/h3>\n
                \n
              1. \n
                val<\/code> \u2014 The value to check <\/p>\n<\/li>\n<\/ol>\n
                PHP is_nan()<\/code> Return Value<\/h3>\n
                The PHP is_nan()<\/code> function returns TRUE<\/code> if val<\/code> is 'not a number', else FALSE<\/code>.<\/p>\n
                PHP is_nan()<\/code> Working Examples<\/h3>\n
                1. is_nan() example<\/h4>\n
                <?php\n\/\/ Invalid calculation, will return a \n\/\/ NaN value\n$nan = acos(8);\nvar_dump($nan, is_nan($nan));\n?><\/code><\/pre>\n
                Output of the above code:<\/p>\n
                float(NAN)\nbool(true)<\/code><\/pre>\n
                Additional Tips from Fellow Developers<\/h3>\n
                Contributed By: darkangel<\/p>\n
                nan\/\"not a number\" is not meant to see if the data type is numeric\/textual\/etc..\nNaN is actually a set of values which can be stored in floating-point variables, but dont actually evaluate to a proper floating point number.\nThe floating point system has three sections: 1 bit for the sign (+\/-), an 8 bit exponent, and a 23 bit fractional part.\nThere are rules governing which combinations of values can be placed into each section, and some values are reserved for numbers such as infinity. This leads to certain combinations being invalid, or in other words, not a number.<\/pre>\n
                <\/code><\/p>\n
                PHP max()<\/code> Function<\/h2>\n
                PHP max()<\/code> Usage<\/h3>\n
                The PHP max()<\/code><\/code> function will give you the highest value in that array. If at least two parameters are provided, max()<\/code> return the biggest of these values.<\/p>\n
                PHP max()<\/code> Syntax<\/h3>\n
                 max ( array $values ) : mixed<\/code><\/pre>\n
                 max ( mixed $value1 [, mixed $... ] ) : mixed<\/code><\/pre>\n
                PHP max()<\/code> Parameters<\/h3>\n
                  \n
                1. \n
                  values<\/code> \u2014 An array containing the values. <\/p>\n<\/li>\n
                2. \n
                  value1<\/code> \u2014 Any comparable value. <\/p>\n<\/li>\n
                3. \n
                  ...<\/code> \u2014 Any comparable value. <\/p>\n<\/li>\n<\/ol>\n
                  PHP max()<\/code> Return Value<\/h3>\n
                  The PHP max()<\/code> function returns the parameter value considered \"highest\" according to standard comparisons. If multiple values of different types evaluate as equal (e.g. 0<\/strong> and 'abc'<\/strong>) the first provided to the function will be returned.<\/p>\n
                  PHP max()<\/code> Working Examples<\/h3>\n
                  1. Example uses of max()<\/h4>\n
                  <?php\necho max(2, 3, 1, 6, 7);  \/\/ 7\necho max(array(2, 4, 5)); \/\/ 5\n\/\/ The string 'hello' when compared to an int is treated as 0\n\/\/ Since the two values are equal, the order they are provided determines the result\necho max(0, 'hello');     \/\/ 0\necho max('hello', 0);     \/\/ hello\n\/\/ Here we are comparing -1 < 0, so 'hello' is the highest value\necho max('hello', -1);    \/\/ hello\n\/\/ With multiple arrays of different lengths, max returns the longest\n$val = max(array(2, 2, 2), array(1, 1, 1, 1)); \/\/ array(1, 1, 1, 1)\n\/\/ Multiple arrays of the same length are compared from left to right\n\/\/ so in our example: 2 == 2, but 5 > 4\n$val = max(array(2, 4, 8), array(2, 5, 1)); \/\/ array(2, 5, 1)\n\/\/ If both an array and non-array are given, the array will be returned\n\/\/ as comparisons treat arrays as greater than any other value\n$val = max('string', array(2, 5, 7), 42);   \/\/ array(2, 5, 7)\n\/\/ If one argument is NULL or a boolean, it will be compared against\n\/\/ other values using the rule FALSE < TRUE regardless of the other types involved\n\/\/ In the below example, -10 is treated as TRUE in the comparison\n$val = max(-10, FALSE); \/\/ -10\n\/\/ 0, on the other hand, is treated as FALSE, so is \"lower than\" TRUE\n$val = max(0, TRUE); \/\/ TRUE\n?><\/code><\/pre>\n
                  Important Points about PHP max()<\/code> Function<\/h3>\n
                    \n
                  1. \n
                     Values of different types will be compared using the standard comparison rules. For instance, a non-numeric string will be compared to an integer as though it were 0<\/strong>, but multiple non-numeric string values will be compared alphanumerically. The actual value returned will be of the original type with no conversion applied. <\/p>\n<\/li>\n<\/ol>\n
                    Additional Tips from Fellow Developers<\/h3>\n
                    Contributed By: keith<\/p>\n
                    The simplest way to get around the fact that max() won't give the key is array_search:\n
                    <?php\n$student_grades = array (\"john\" => 100, \"sarah\" => 90, \"anne\" => 100);\n$top_student = array_search(max($student_grades),$student_grades); \/\/ john\n?>
                    \nThis could also be done with array_flip, though overwriting will mean that it gets the last max value rather than the first:\n
                    <?php\n$grades_index = array_flip($student_grades);\n$top_student = $grades_index[max($student_grades)]; \/\/ anne\n?>
                    \nTo get all the max value keys:\n
                    <?php\n$top_students = array_keys($student_grades,max($student_grades)); \/\/ john, anne\n?>
                    <\/pre>\n
                    <\/code><\/p>\n
                    Contributed By: costinu<\/p>\n
                    max(null, 0) = null \nmax(0, null) = 0<\/pre>\n
                    <\/code><\/p>\n
                    Contributed By: volch5<\/p>\n
                    max() (and min()) on DateTime objects compares them like dates (with timezone info) and returns DateTime object.\n
                    <?php \n$dt1 = new DateTime('2014-05-07 18:53', new DateTimeZone('Europe\/Kiev'));\n$dt2 = new DateTime('2014-05-07 16:53', new DateTimeZone('UTC'));\necho max($dt1,$dt2)->format(DateTime::RFC3339) . PHP_EOL; \/\/ 2014-05-07T16:53:00+00:00\necho min($dt1,$dt2)->format(DateTime::RFC3339) . PHP_EOL; \/\/ 2014-05-07T18:53:00+03:00\n?>
                    \nIt works at least 5.3.3-7+squeeze17<\/pre>\n
                    <\/code><\/p>\n
                    Contributed By: <\/p>\n
                    Notice that whenever there is a Number in front of the String, it will be used for Comparison.\n
                    <?php\n  max('7iuwmssuxue', 1); \/\/returns 7iuwmssuxu\n  max('-7suidha', -4); \/\/returns -4\n?>
                    \nBut just if it is in front of the String\n
                    <?php\n  max('sdihatewin7wduiw', 3); \/\/returns 3\n?>
                    <\/pre>\n
                    <\/code><\/p>\n
                    PHP min()<\/code> Function<\/h2>\n
                    PHP min()<\/code> Usage<\/h3>\n
                    The PHP min()<\/code><\/code> function will give you the lowest value in that array. If at least two parameters are provided, min()<\/code> return the smallest of these values.<\/p>\n
                    PHP min()<\/code> Syntax<\/h3>\n
                     min ( array $values ) : mixed<\/code><\/pre>\n
                     min ( mixed $value1 [, mixed $... ] ) : mixed<\/code><\/pre>\n
                    PHP min()<\/code> Parameters<\/h3>\n
                      \n
                    1. \n
                      values<\/code> \u2014 An array containing the values. <\/p>\n<\/li>\n
                    2. \n
                      value1<\/code> \u2014 Any comparable value. <\/p>\n<\/li>\n
                    3. \n
                      ...<\/code> \u2014 Any comparable value. <\/p>\n<\/li>\n<\/ol>\n
                      PHP min()<\/code> Return Value<\/h3>\n
                      The PHP min()<\/code> function returns the parameter value considered \"lowest\" according to standard comparisons. If multiple values of different types evaluate as equal (e.g. 0<\/strong> and 'abc'<\/strong>) the first provided to the function will be returned.<\/p>\n
                      PHP min()<\/code> Working Examples<\/h3>\n
                      1. Example uses of min()<\/h4>\n
                      <?php\necho min(2, 3, 1, 6, 7);  \/\/ 1\necho min(array(2, 4, 5)); \/\/ 2\n\/\/ The string 'hello' when compared to an int is treated as 0\n\/\/ Since the two values are equal, the order they are provided determines the result\necho min(0, 'hello');     \/\/ 0\necho min('hello', 0);     \/\/ hello\n\/\/ Here we are comparing -1 < 0, so -1 is the lowest value\necho min('hello', -1);    \/\/ -1\n\/\/ With multiple arrays of different lengths, min returns the shortest\n$val = min(array(2, 2, 2), array(1, 1, 1, 1)); \/\/ array(2, 2, 2)\n\/\/ Multiple arrays of the same length are compared from left to right\n\/\/ so in our example: 2 == 2, but 4 < 5\n$val = min(array(2, 4, 8), array(2, 5, 1)); \/\/ array(2, 4, 8)\n\/\/ If both an array and non-array are given, the array is never returned\n\/\/ as comparisons treat arrays as greater than any other value\n$val = min('string', array(2, 5, 7), 42);   \/\/ string\n\/\/ If one argument is NULL or a boolean, it will be compared against\n\/\/ other values using the rules FALSE < TRUE and NULL == FALSE regardless of the \n\/\/ other types involved\n\/\/ In the below examples, both -10 and 10 are treated as TRUE in the comparison\n$val = min(-10, FALSE, 10); \/\/ FALSE\n$val = min(-10, NULL, 10);  \/\/ NULL\n\/\/ 0, on the other hand, is treated as FALSE, so is \"lower than\" TRUE\n$val = min(0, TRUE); \/\/ 0\n?><\/code><\/pre>\n
                      Important Points about PHP min()<\/code> Function<\/h3>\n
                        \n
                      1. \n
                         Values of different types will be compared using the standard comparison rules. For instance, a non-numeric string will be compared to an integer as though it were 0<\/strong>, but multiple non-numeric string values will be compared alphanumerically. The actual value returned will be of the original type with no conversion applied. <\/p>\n<\/li>\n<\/ol>\n
                        PHP round()<\/code> Function<\/h2>\n
                        PHP round()<\/code> Usage<\/h3>\n
                        The PHP round()<\/code><\/code> function will give you the rounded value of val<\/code> to specified precision<\/code> (number of digits after the decimal point). precision<\/code> can also be negative or zero (default).<\/p>\n
                        PHP round()<\/code> Syntax<\/h3>\n
                         round ( float $val [, int $precision = 0 [, int $mode = PHP_ROUND_HALF_UP ]] ) : float<\/code><\/pre>\n
                        PHP round()<\/code> Parameters<\/h3>\n
                          \n
                        1. \n
                          val<\/code> \u2014 The value to round. <\/p>\n<\/li>\n
                        2. \n
                          precision<\/code> \u2014 The optional number of decimal digits to round to. <\/p>\n<\/li>\n
                        3. \n
                          mode<\/code> \u2014 Use one of the following constants to specify the mode in which rounding occurs. <\/p>\n<\/li>\n<\/ol>\n
                          PHP round()<\/code> Return Value<\/h3>\n
                          The PHP round()<\/code> function returns the value rounded to the given precision<\/code> as a float.<\/p>\n
                          PHP round()<\/code> Working Examples<\/h3>\n
                          1. round() examples<\/h4>\n
                          <?php\nvar_dump(round(3.4));\nvar_dump(round(3.5));\nvar_dump(round(3.6));\nvar_dump(round(3.6, 0));\nvar_dump(round(1.95583, 2));\nvar_dump(round(1241757, -3));\nvar_dump(round(5.045, 2));\nvar_dump(round(5.055, 2));\n?><\/code><\/pre>\n
                          Output of the above code:<\/p>\n
                          float(3)\nfloat(4)\nfloat(4)\nfloat(4)\nfloat(1.96)\nfloat(1242000)\nfloat(5.05)\nfloat(5.06)<\/code><\/pre>\n
                          2. How precision affects a float<\/h4>\n
                          <?php\n$number = 1346.21;\nvar_dump(round($number, 2));\nvar_dump(round($number, 1));\nvar_dump(round($number, 0));\nvar_dump(round($number, -1));\nvar_dump(round($number, -2));\nvar_dump(round($number, -3));\nvar_dump(round($number, -4));\n?><\/code><\/pre>\n
                          Output of the above code:<\/p>\n
                          float(1346.21)\nfloat(1346.2)\nfloat(1346)\nfloat(1350)\nfloat(1300)\nfloat(1000)\nfloat(0)<\/code><\/pre>\n
                          3. mode examples<\/h4>\n
                          <?php\necho 'Rounding modes with 9.5' . PHP_EOL;\nvar_dump(round(9.5, 0, PHP_ROUND_HALF_UP));\nvar_dump(round(9.5, 0, PHP_ROUND_HALF_DOWN));\nvar_dump(round(9.5, 0, PHP_ROUND_HALF_EVEN));\nvar_dump(round(9.5, 0, PHP_ROUND_HALF_ODD));\necho 'Rounding modes with 8.5' . PHP_EOL;\nvar_dump(round(8.5, 0, PHP_ROUND_HALF_UP));\nvar_dump(round(8.5, 0, PHP_ROUND_HALF_DOWN));\nvar_dump(round(8.5, 0, PHP_ROUND_HALF_EVEN));\nvar_dump(round(8.5, 0, PHP_ROUND_HALF_ODD));\n?><\/code><\/pre>\n
                          Output of the above code:<\/p>\n
                          Rounding modes with 9.5\nfloat(10)\nfloat(9)\nfloat(10)\nfloat(9)\nRounding modes with 8.5\nfloat(9)\nfloat(8)\nfloat(8)\nfloat(9)<\/code><\/pre>\n
                          4. mode with precision examples<\/h4>\n
                          <?php\necho 'Using PHP_ROUND_HALF_UP with 1 decimal digit precision' . PHP_EOL;\nvar_dump(round( 1.55, 1, PHP_ROUND_HALF_UP));\nvar_dump(round( 1.54, 1, PHP_ROUND_HALF_UP));\nvar_dump(round(-1.55, 1, PHP_ROUND_HALF_UP));\nvar_dump(round(-1.54, 1, PHP_ROUND_HALF_UP));\necho PHP_EOL;\necho 'Using PHP_ROUND_HALF_DOWN with 1 decimal digit precision' . PHP_EOL;\nvar_dump(round( 1.55, 1, PHP_ROUND_HALF_DOWN));\nvar_dump(round( 1.54, 1, PHP_ROUND_HALF_DOWN));\nvar_dump(round(-1.55, 1, PHP_ROUND_HALF_DOWN));\nvar_dump(round(-1.54, 1, PHP_ROUND_HALF_DOWN));\necho PHP_EOL;\necho 'Using PHP_ROUND_HALF_EVEN with 1 decimal digit precision' . PHP_EOL;\nvar_dump(round( 1.55, 1, PHP_ROUND_HALF_EVEN));\nvar_dump(round( 1.54, 1, PHP_ROUND_HALF_EVEN));\nvar_dump(round(-1.55, 1, PHP_ROUND_HALF_EVEN));\nvar_dump(round(-1.54, 1, PHP_ROUND_HALF_EVEN));\necho PHP_EOL;\necho 'Using PHP_ROUND_HALF_ODD with 1 decimal digit precision' . PHP_EOL;\nvar_dump(round( 1.55, 1, PHP_ROUND_HALF_ODD));\nvar_dump(round( 1.54, 1, PHP_ROUND_HALF_ODD));\nvar_dump(round(-1.55, 1, PHP_ROUND_HALF_ODD));\nvar_dump(round(-1.54, 1, PHP_ROUND_HALF_ODD));\n?><\/code><\/pre>\n
                          Output of the above code:<\/p>\n
                          Using PHP_ROUND_HALF_UP with 1 decimal digit precision\nfloat(1.6)\nfloat(1.5)\nfloat(-1.6)\nfloat(-1.5)\nUsing PHP_ROUND_HALF_DOWN with 1 decimal digit precision\nfloat(1.5)\nfloat(1.5)\nfloat(-1.5)\nfloat(-1.5)\nUsing PHP_ROUND_HALF_EVEN with 1 decimal digit precision\nfloat(1.6)\nfloat(1.5)\nfloat(-1.6)\nfloat(-1.5)\nUsing PHP_ROUND_HALF_ODD with 1 decimal digit precision\nfloat(1.5)\nfloat(1.5)\nfloat(-1.5)\nfloat(-1.5)<\/code><\/pre>\n
                          Changelog for PHP round()<\/code> Function<\/h3>\n
                          5.3.0 \u2014 <\/strong> The mode<\/code> parameter was introduced. <\/p>\n
                          5.2.7 \u2014 <\/strong> The inner workings of round()<\/code> was changed to conform to the C99 standard. <\/p>\n
                          Additional Tips from Fellow Developers<\/h3>\n
                          Contributed By: takingsides<\/p>\n
                          In my opinion this function lacks two flags:\n- PHP_ROUND_UP - Always round up.\n- PHP_ROUND_DOWN - Always round down.\nIn accounting, it's often necessary to always round up, or down to a precision of thousandths.\n
                          <?php\nfunction round_up($number, $precision = 2)\n{\n    $fig = (int) str_pad('1', $precision, '0');\n    return (ceil($number * $fig) \/ $fig);\n}\nfunction round_down($number, $precision = 2)\n{\n    $fig = (int) str_pad('1', $precision, '0');\n    return (floor($number * $fig) \/ $fig);\n}\n?>
                          <\/pre>\n
                          <\/code><\/p>\n
                          Contributed By: depaula<\/p>\n
                          As PHP doesn't have a a native number truncate function, this is my solution - a function that can be usefull if you need truncate instead round a number.\n
                          <?php\n\/**\n * Truncate a float number, example: <code>truncate(-1.49999, 2); \/\/ returns -1.49\n * truncate(.49999, 3); \/\/ returns 0.499\n * <\/code>\n * @param float $val Float number to be truncate\n * @param int f Number of precision\n * @return float\n *\/\nfunction truncate($val, $f=\"0\")\n{\n    if(($p = strpos($val, '.')) !== false) {\n        $val = floatval(substr($val, 0, $p + 1 + $f));\n    }\n    return $val;\n}\n?>
                          \nOriginally posted in http:\/\/stackoverflow.com\/a\/12710283\/1596489<\/pre>\n
                          <\/code><\/p>\n
                          Contributed By: slimusgm<\/p>\n
                          If you have negative zero and you need return positive number simple add +0:\n$number = -2.38419e-07;\nvar_dump(round($number,1));\/\/float(-0)\nvar_dump(round($number,1) + 0);\/\/float(0)<\/pre>\n
                          <\/code><\/p>\n
                          Contributed By: djcox99<\/p>\n
                          I discovered that under some conditions you can get rounding errors with round when converting the number to a string afterwards.\nTo fix this I swapped round() for number_format().\nUnfortunately i cant give an example (because the number cant be represented as a string !)\nessentially I had round(0.688888889,2);\nwhich would stay as 0.68888889 when printed as a string.\nBut using number_format it correctly became 0.69.<\/pre>\n
                          <\/code><\/p>\n
                          Contributed By: twan<\/p>\n
                          If you'd only want to round for displaying variables (not for calculating on the rounded result) then you should use printf with the float: \n \n
                          <?php printf (\"%6.2f\",3.39532); ?>
                           \n \nThis returns: 3.40 .<\/pre>\n
                          <\/code><\/p>\n
                          Contributed By: Anonymous<\/p>\n
                          Here is function that rounds to a specified increment, but always up. I had to use it for price adjustment that always went up to $5 increments. \n \n
                          <?php  \nfunction roundUpTo($number, $increments) { \n    $increments = 1 \/ $increments; \n    return (ceil($number * $increments) \/ $increments); \n} \n?>
                          <\/pre>\n
                          <\/code><\/p>\n","protected":false},"excerpt":{"rendered":"
                          Numerical Functions in PHP Function Name Function Description abs() Absolute value ceil() Round fractions up floor() Round fractions down fmod() Returns the floating point remainder (modulo) of the division of the arguments is_finite() Finds whether a value is a legal finite number is_infinite() Finds whether a value is infinite is_nan() Finds whether a value is […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[8,5],"class_list":["post-61","post","type-post","status-publish","format-standard","hentry","category-reference","tag-math","tag-php"],"_links":{"self":[{"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/posts\/61","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/comments?post=61"}],"version-history":[{"count":0,"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/posts\/61\/revisions"}],"wp:attachment":[{"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/media?parent=61"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/categories?post=61"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/tags?post=61"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}