{"id":65,"date":"2019-08-30T19:52:51","date_gmt":"2019-08-30T19:52:51","guid":{"rendered":"https:\/\/tutorialio.com\/?p=65"},"modified":"2019-08-30T19:52:51","modified_gmt":"2019-08-30T19:52:51","slug":"arbitrary-precision-maths-functions-in-php-bc-math","status":"publish","type":"post","link":"https:\/\/hellonitish.com\/blog\/arbitrary-precision-maths-functions-in-php-bc-math\/","title":{"rendered":"Arbitrary Precision Maths Functions in PHP (BC Math)"},"content":{"rendered":"\n\n\n\n\n\n\n\n\n\n\n\n\n
Arbitrary Precision Maths Functions in PHP<\/caption>\n<\/caption>\n
Function Name<\/th>\nFunction Description<\/th>\n<\/tr>\n
bcadd()<\/a><\/td>\nAdd two arbitrary precision numbers<\/td>\n<\/tr>\n
bccomp()<\/a><\/td>\nCompare two arbitrary precision numbers<\/td>\n<\/tr>\n
bcdiv()<\/a><\/td>\nDivide two arbitrary precision numbers<\/td>\n<\/tr>\n
bcmod()<\/a><\/td>\nGet modulus of an arbitrary precision number<\/td>\n<\/tr>\n
bcmul()<\/a><\/td>\nMultiply two arbitrary precision numbers<\/td>\n<\/tr>\n
bcpow()<\/a><\/td>\nRaise an arbitrary precision number to another<\/td>\n<\/tr>\n
bcpowmod()<\/a><\/td>\nRaise an arbitrary precision number to another, reduced by a specified modulus<\/td>\n<\/tr>\n
bcscale()<\/a><\/td>\nSet or get default scale parameter for all bc math functions<\/td>\n<\/tr>\n
bcsqrt()<\/a><\/td>\nGet the square root of an arbitrary precision number<\/td>\n<\/tr>\n
bcsub()<\/a><\/td>\nSubtract one arbitrary precision number from another<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

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

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

The PHP bcadd()<\/code><\/code> function will sums left_operand<\/code> and right_operand<\/code>.<\/p>\n

PHP bcadd()<\/code> Syntax<\/h3>\n
 bcadd ( string $left_operand , string $right_operand [, int $scale = 0 ] ) : string<\/code><\/pre>\n
PHP bcadd()<\/code> Parameters<\/h3>\n
    \n
  1. \n
    left_operand<\/code> \u2014 The left operand, as a string. <\/p>\n<\/li>\n
  2. \n
    right_operand<\/code> \u2014 The right operand, as a string. <\/p>\n<\/li>\n
  3. \n
    scale<\/code> \u2014 This optional parameter is used to set the number of digits after the decimal place in the result. If omitted, it will default to the scale set globally with the bcscale()<\/code> function, or fallback to 0 if this has not been set.<\/p>\n<\/li>\n<\/ol>\n
    PHP bcadd()<\/code> Return Value<\/h3>\n
    The PHP bcadd()<\/code> function returns the sum of the two operands, as a string.<\/p>\n
    PHP bcadd()<\/code> Working Examples<\/h3>\n
    1. bcadd() example<\/h4>\n
    <?php\n$a = '1.234';\n$b = '5';\necho bcadd($a, $b);     \/\/ 6\necho bcadd($a, $b, 4);  \/\/ 6.2340\n?><\/code><\/pre>\n
    Additional Tips from Fellow Developers<\/h3>\n
    Contributed By: Nitrogen<\/p>\n
    I made this to add an unlimited size of numbers together.. \n \nThis could be useful for those without the BCMath extension. \n \nIt allows decimals, and optional $Scale parameter.  If $Scale isn't specified, then it'll automatically adjust to show the correct number of decimals. \n \n
    <?php \n \nfunction Add($Num1,$Num2,$Scale=null) { \n  \/\/ check if they're valid positive numbers, extract the whole numbers and decimals \n  if(!preg_match(\"\/^\\+?(\\d+)(\\.\\d+)?$\/\",$Num1,$Tmp1)|| \n     !preg_match(\"\/^\\+?(\\d+)(\\.\\d+)?$\/\",$Num2,$Tmp2)) return('0'); \n \n  \/\/ this is where the result is stored \n  $Output=array(); \n \n  \/\/ remove ending zeroes from decimals and remove point \n  $Dec1=isset($Tmp1[2])?rtrim(substr($Tmp1[2],1),'0'):''; \n  $Dec2=isset($Tmp2[2])?rtrim(substr($Tmp2[2],1),'0'):''; \n \n  \/\/ calculate the longest length of decimals \n  $DLen=max(strlen($Dec1),strlen($Dec2)); \n \n  \/\/ if $Scale is null, automatically set it to the amount of decimal places for accuracy \n  if($Scale==null) $Scale=$DLen; \n \n  \/\/ remove leading zeroes and reverse the whole numbers, then append padded decimals on the end \n  $Num1=strrev(ltrim($Tmp1[1],'0').str_pad($Dec1,$DLen,'0')); \n  $Num2=strrev(ltrim($Tmp2[1],'0').str_pad($Dec2,$DLen,'0')); \n \n  \/\/ calculate the longest length we need to process \n  $MLen=max(strlen($Num1),strlen($Num2)); \n \n  \/\/ pad the two numbers so they are of equal length (both equal to $MLen) \n  $Num1=str_pad($Num1,$MLen,'0'); \n  $Num2=str_pad($Num2,$MLen,'0'); \n \n  \/\/ process each digit, keep the ones, carry the tens (remainders) \n  for($i=0;$i<$MLen;$i++) { \n    $Sum=((int)$Num1{$i}+(int)$Num2{$i}); \n    if(isset($Output[$i])) $Sum+=$Output[$i]; \n    $Output[$i]=$Sum%10; \n    if($Sum>9) $Output[$i+1]=1; \n  } \n \n  \/\/ convert the array to string and reverse it \n  $Output=strrev(implode($Output)); \n \n  \/\/ substring the decimal digits from the result, pad if necessary (if $Scale > amount of actual decimals) \n  \/\/ next, since actual zero values can cause a problem with the substring values, if so, just simply give '0' \n  \/\/ next, append the decimal value, if $Scale is defined, and return result \n  $Decimal=str_pad(substr($Output,-$DLen,$Scale),$Scale,'0'); \n  $Output=(($MLen-$DLen<1)?'0':substr($Output,0,-$DLen)); \n  $Output.=(($Scale>0)?\".{$Decimal}\":''); \n  return($Output); \n} \n \n$A=\"5650175242.508133742\"; \n$B=\"308437806.831153821478770\"; \n \nprintf(\"  Add(%s,%s);\\r\\n\/\/ %s\\r\\n\\r\\n\",$A,$B,  Add($A,$B)); \nprintf(\"BCAdd(%s,%s);\\r\\n\/\/ %s\\r\\n\\r\\n\",$A,$B,BCAdd($A,$B)); \n \n\/* \n  This will produce the following.. \n    Add(5650175242.508133742,308437806.831153821478770); \n  \/\/ 5958613049.33928756347877 \n \n  BCAdd(5650175242.508133742,308437806.831153821478770); \n  \/\/ 5958613049 \n*\/ \n \n?>
     \n \nIt was a fun experience making, and thought I'd share it. \nEnjoy, \nNitrogen.<\/pre>\n
    <\/code><\/p>\n
    PHP bccomp()<\/code> Function<\/h2>\n
    PHP bccomp()<\/code> Usage<\/h3>\n
    The PHP bccomp()<\/code><\/code> function will give you the result as an integer.<\/p>\n
    PHP bccomp()<\/code> Syntax<\/h3>\n
     bccomp ( string $left_operand , string $right_operand [, int $scale = 0 ] ) : int<\/code><\/pre>\n
    PHP bccomp()<\/code> Parameters<\/h3>\n
      \n
    1. \n
      left_operand<\/code> \u2014 The left operand, as a string. <\/p>\n<\/li>\n
    2. \n
      right_operand<\/code> \u2014 The right operand, as a string. <\/p>\n<\/li>\n
    3. \n
      scale<\/code> \u2014 The optional scale parameter is used to set the number of digits after the decimal place which will be used in the comparison. <\/p>\n<\/li>\n<\/ol>\n
      PHP bccomp()<\/code> Return Value<\/h3>\n
      The PHP bccomp()<\/code> function returns 0 if the two operands are equal, 1 if the left_operand<\/code> is larger than the right_operand<\/code>, -1 otherwise.<\/p>\n
      PHP bccomp()<\/code> Working Examples<\/h3>\n
      1. bccomp() example<\/h4>\n
      <?php\necho bccomp('1', '2') . \"\\n\";   \/\/ -1\necho bccomp('1.00001', '1', 3); \/\/ 0\necho bccomp('1.00001', '1', 5); \/\/ 1\n?><\/code><\/pre>\n
      Additional Tips from Fellow Developers<\/h3>\n
      Contributed By: Robert Lozyniak<\/p>\n
      Beware that negative zero does not compare equal to positive zero.<\/pre>\n
      <\/code><\/p>\n
      PHP bcdiv()<\/code> Function<\/h2>\n
      PHP bcdiv()<\/code> Usage<\/h3>\n
      The PHP bcdiv()<\/code><\/code> function will divides the dividend<\/code> by the divisor<\/code>.<\/p>\n
      PHP bcdiv()<\/code> Syntax<\/h3>\n
       bcdiv ( string $dividend , string $divisor [, int $scale = 0 ] ) : string<\/code><\/pre>\n
      PHP bcdiv()<\/code> Parameters<\/h3>\n
        \n
      1. \n
        dividend<\/code> \u2014 The dividend, as a string. <\/p>\n<\/li>\n
      2. \n
        divisor<\/code> \u2014 The divisor, as a string. <\/p>\n<\/li>\n
      3. \n
        scale<\/code> \u2014 This optional parameter is used to set the number of digits after the decimal place in the result. If omitted, it will default to the scale set globally with the bcscale()<\/code> function, or fallback to 0 if this has not been set.<\/p>\n<\/li>\n<\/ol>\n
        PHP bcdiv()<\/code> Return Value<\/h3>\n
        The PHP bcdiv()<\/code> function returns the result of the division as a string, or NULL<\/code> if divisor<\/code> is 0<\/strong>.<\/p>\n
        PHP bcdiv()<\/code> Working Examples<\/h3>\n
        1. bcdiv() example<\/h4>\n
        <?php\necho bcdiv('105', '6.55957', 3);  \/\/ 16.007\n?><\/code><\/pre>\n
        PHP bcmod()<\/code> Function<\/h2>\n
        PHP bcmod()<\/code> Usage<\/h3>\n
        The PHP bcmod()<\/code><\/code> function will get modulus of an arbitrary precision number.<\/p>\n
        PHP bcmod()<\/code> Syntax<\/h3>\n
         bcmod ( string $dividend , string $divisor [, int $scale = 0 ] ) : string<\/code><\/pre>\n
        PHP bcmod()<\/code> Parameters<\/h3>\n
          \n
        1. \n
          dividend<\/code> \u2014 The dividend, as a string. <\/p>\n<\/li>\n
        2. \n
          divisor<\/code> \u2014 The divisor, as a string. <\/p>\n<\/li>\n<\/ol>\n
          PHP bcmod()<\/code> Return Value<\/h3>\n
          The PHP bcmod()<\/code> function returns the modulus as a string, or NULL<\/code> if divisor<\/code> is 0<\/strong>.<\/p>\n
          PHP bcmod()<\/code> Working Examples<\/h3>\n
          1. bcmod() example<\/h4>\n
          <?php\nbcscale(0);\necho bcmod( '5',  '3'); \/\/  2\necho bcmod( '5', '-3'); \/\/  2\necho bcmod('-5',  '3'); \/\/ -2\necho bcmod('-5', '-3'); \/\/ -2\n?><\/code><\/pre>\n
          2. bcmod() with decimals<\/h4>\n
          <?php\nbcscale(1);\necho bcmod('5.7', '1.3'); \/\/ 0.5 as of PHP 7.2.0; 0 previously\n?><\/code><\/pre>\n
          Changelog for PHP bcmod()<\/code> Function<\/h3>\n
          7.2.0 \u2014 <\/strong> dividend<\/code> and divisor<\/code> are no longer truncated to integer, so now the behavior of bcmod()<\/code> follows fmod()<\/code> rather than the % operator. <\/p>\n
          7.2.0 \u2014 <\/strong> The scale<\/code> parameter was added. <\/p>\n
          PHP bcmul()<\/code> Function<\/h2>\n
          PHP bcmul()<\/code> Usage<\/h3>\n
          The PHP bcmul()<\/code><\/code> function will multiply two arbitrary precision numbers.<\/p>\n
          PHP bcmul()<\/code> Syntax<\/h3>\n
           bcmul ( string $left_operand , string $right_operand [, int $scale = 0 ] ) : string<\/code><\/pre>\n
          PHP bcmul()<\/code> Parameters<\/h3>\n
            \n
          1. \n
            left_operand<\/code> \u2014 The left operand, as a string. <\/p>\n<\/li>\n
          2. \n
            right_operand<\/code> \u2014 The right operand, as a string. <\/p>\n<\/li>\n
          3. \n
            scale<\/code> \u2014 This optional parameter is used to set the number of digits after the decimal place in the result. If omitted, it will default to the scale set globally with the bcscale()<\/code> function, or fallback to 0 if this has not been set.<\/p>\n<\/li>\n<\/ol>\n
            PHP bcmul()<\/code> Return Value<\/h3>\n
            The PHP bcmul()<\/code> function returns the result as a string.<\/p>\n
            PHP bcmul()<\/code> Working Examples<\/h3>\n
            1. bcmul() example<\/h4>\n
            <?php\necho bcmul('1.34747474747', '35', 3); \/\/ 47.161\necho bcmul('2', '4'); \/\/ 8\n?><\/code><\/pre>\n
            2. bcmul() scale example<\/h4>\n
            <?php\necho bcmul('5', '2', 2);     \/\/ prints \"10\", not \"10.00\"\n?><\/code><\/pre>\n
            Changelog for PHP bcmul()<\/code> Function<\/h3>\n
            7.3.0 \u2014 <\/strong> bcmul()<\/code> now returns numbers with the requested scale. Formerly, the returned numbers may have omitted trailing decimal zeroes. <\/p>\n
            Important Points about PHP bcmul()<\/code> Function<\/h3>\n
              \n
            1. \n
               Before PHP 7.3.0 bcmul()<\/code> may return a result with fewer digits after the decimal point than the scale<\/code> parameter would indicate. This only occurs when the result doesn't require all of the precision allowed by the scale<\/code>. For example: <\/p>\n<\/li>\n
              <?php\necho bcmul('5', '2', 2);     \/\/ prints \"10\", not \"10.00\"\n?><\/code><\/pre>\n<\/li>\n<\/ol>\n
              PHP bcpow()<\/code> Function<\/h2>\n
              PHP bcpow()<\/code> Usage<\/h3>\n
              The PHP bcpow()<\/code><\/code> function will raise an arbitrary precision number to another.<\/p>\n
              PHP bcpow()<\/code> Syntax<\/h3>\n
               bcpow ( string $base , string $exponent [, int $scale = 0 ] ) : string<\/code><\/pre>\n
              PHP bcpow()<\/code> Parameters<\/h3>\n
                \n
              1. \n
                base<\/code> \u2014 The base, as a string. <\/p>\n<\/li>\n
              2. \n
                exponent<\/code> \u2014 The exponent, as a string. If the exponent is non-integral, it is truncated. The valid range of the exponent is platform specific, but is at least -2147483648 to 2147483647. <\/p>\n<\/li>\n
              3. \n
                scale<\/code> \u2014 This optional parameter is used to set the number of digits after the decimal place in the result. If omitted, it will default to the scale set globally with the bcscale()<\/code> function, or fallback to 0 if this has not been set.<\/p>\n<\/li>\n<\/ol>\n
                PHP bcpow()<\/code> Return Value<\/h3>\n
                The PHP bcpow()<\/code> function returns the result as a string.<\/p>\n
                PHP bcpow()<\/code> Working Examples<\/h3>\n
                1. bcpow() example<\/h4>\n
                <?php\necho bcpow('4.2', '3', 2); \/\/ 74.08\n?><\/code><\/pre>\n
                2. bcpow() scale example<\/h4>\n
                <?php\necho bcpow('5', '2', 2);     \/\/ prints \"25\", not \"25.00\"\n?><\/code><\/pre>\n
                Changelog for PHP bcpow()<\/code> Function<\/h3>\n
                7.3.0 \u2014 <\/strong> bcpow()<\/code> now returns numbers with the requested scale. Formerly, the returned numbers may have omitted trailing decimal zeroes. <\/p>\n
                Important Points about PHP bcpow()<\/code> Function<\/h3>\n
                  \n
                1. \n
                   Before PHP 7.3.0 bcpow()<\/code> may return a result with fewer digits after the decimal point than the scale<\/code> parameter would indicate. This only occurs when the result doesn't require all of the precision allowed by the scale<\/code>. For example: <\/p>\n<\/li>\n
                  <?php\necho bcpow('5', '2', 2);     \/\/ prints \"25\", not \"25.00\"\n?><\/code><\/pre>\n<\/li>\n<\/ol>\n
                  PHP bcpowmod()<\/code> Function<\/h2>\n
                  PHP bcpowmod()<\/code> Usage<\/h3>\n
                  The PHP bcpowmod()<\/code><\/code> function will raise an arbitrary precision number to another, reduced by a specified modulus.<\/p>\n
                  PHP bcpowmod()<\/code> Syntax<\/h3>\n
                   bcpowmod ( string $base , string $exponent , string $modulus [, int $scale = 0 ] ) : string<\/code><\/pre>\n
                  PHP bcpowmod()<\/code> Parameters<\/h3>\n
                    \n
                  1. \n
                    base<\/code> \u2014 The base, as an integral string (i.e. the scale has to be zero). <\/p>\n<\/li>\n
                  2. \n
                    exponent<\/code> \u2014 The exponent, as an non-negative, integral string (i.e. the scale has to be zero). <\/p>\n<\/li>\n
                  3. \n
                    modulus<\/code> \u2014 The modulus, as an integral string (i.e. the scale has to be zero). <\/p>\n<\/li>\n
                  4. \n
                    scale<\/code> \u2014 This optional parameter is used to set the number of digits after the decimal place in the result. If omitted, it will default to the scale set globally with the bcscale()<\/code> function, or fallback to 0 if this has not been set.<\/p>\n<\/li>\n<\/ol>\n
                    PHP bcpowmod()<\/code> Return Value<\/h3>\n
                    The PHP bcpowmod()<\/code> function returns the result as a string, or FALSE<\/code> if modulus<\/code> is 0<\/strong> or exponent<\/code> is negative.<\/p>\n
                    Important Points about PHP bcpowmod()<\/code> Function<\/h3>\n
                      \n
                    1. \n
                       Because this method uses the modulus operation, numbers which are not positive integers may give unexpected results. <\/p>\n<\/li>\n<\/ol>\n
                      PHP bcscale()<\/code> Function<\/h2>\n
                      PHP bcscale()<\/code> Usage<\/h3>\n
                      The PHP bcscale()<\/code><\/code> function will set or get default scale parameter for all bc math functions.<\/p>\n
                      PHP bcscale()<\/code> Syntax<\/h3>\n
                       bcscale ( int $scale ) : int<\/code><\/pre>\n
                       bcscale ( void ) : int<\/code><\/pre>\n
                      PHP bcscale()<\/code> Parameters<\/h3>\n
                        \n
                      1. \n
                        scale<\/code> \u2014 The scale factor. <\/p>\n<\/li>\n<\/ol>\n
                        PHP bcscale()<\/code> Return Value<\/h3>\n
                        The PHP bcscale()<\/code> function returns the old scale when used as setter. Otherwise the current scale is returned.<\/p>\n
                        PHP bcscale()<\/code> Working Examples<\/h3>\n
                        1. bcscale() example<\/h4>\n
                        <?php\n\/\/ default scale : 3\nbcscale(3);\necho bcdiv('105', '6.55957'); \/\/ 16.007\n\/\/ this is the same without bcscale()\necho bcdiv('105', '6.55957', 3); \/\/ 16.007\n?><\/code><\/pre>\n
                        Changelog for PHP bcscale()<\/code> Function<\/h3>\n
                        7.3.0 \u2014 <\/strong> bcscale()<\/code> can now be used to get the current scale factor; when used as setter, it now returns the old scale value. Formerly, scale<\/code> was mandatory, and bcscale()<\/code> always returned TRUE<\/code>. <\/p>\n
                        Additional Tips from Fellow Developers<\/h3>\n
                        Contributed By: sicerwork<\/p>\n
                        Executing bcsacle() will change the scale value of fpm.conf, not only the current process.<\/pre>\n
                        <\/code><\/p>\n
                        Contributed By: mwgamera<\/p>\n
                        These functions DO NOT round off your values. No arbitrary precision libraries do it this way. It stops calculating after reaching scale of decimal places, which mean that your value is cut off after scale number of digits, not rounded. To do the rounding use something like this:\n
                        <?php\n        function bcround($number, $scale=0) {\n                $fix = \"5\";\n                for ($i=0;$i<$scale;$i++) $fix=\"0$fix\";\n                $number = bcadd($number, \"0.$fix\", $scale+1);\n                return    bcdiv($number, \"1.0\",    $scale);\n        }\n?>
                        <\/pre>\n
                        <\/code><\/p>\n
                        PHP bcsqrt()<\/code> Function<\/h2>\n
                        PHP bcsqrt()<\/code> Usage<\/h3>\n
                        The PHP bcsqrt()<\/code><\/code> function will get the square root of an arbitrary precision number.<\/p>\n
                        PHP bcsqrt()<\/code> Syntax<\/h3>\n
                         bcsqrt ( string $operand [, int $scale = 0 ] ) : string<\/code><\/pre>\n
                        PHP bcsqrt()<\/code> Parameters<\/h3>\n
                          \n
                        1. \n
                          operand<\/code> \u2014 The operand, as a string. <\/p>\n<\/li>\n
                        2. \n
                          scale<\/code> \u2014 This optional parameter is used to set the number of digits after the decimal place in the result. If omitted, it will default to the scale set globally with the bcscale()<\/code> function, or fallback to 0 if this has not been set.<\/p>\n<\/li>\n<\/ol>\n
                          PHP bcsqrt()<\/code> Return Value<\/h3>\n
                          The PHP bcsqrt()<\/code> function returns the square root as a string, or NULL<\/code> if operand<\/code> is negative.<\/p>\n
                          PHP bcsqrt()<\/code> Working Examples<\/h3>\n
                          1. bcsqrt() example<\/h4>\n
                          <?php\necho bcsqrt('2', 3); \/\/ 1.414\n?><\/code><\/pre>\n
                          PHP bcsub()<\/code> Function<\/h2>\n
                          PHP bcsub()<\/code> Usage<\/h3>\n
                          The PHP bcsub()<\/code><\/code> function will subtract one arbitrary precision number from another.<\/p>\n
                          PHP bcsub()<\/code> Syntax<\/h3>\n
                           bcsub ( string $left_operand , string $right_operand [, int $scale = 0 ] ) : string<\/code><\/pre>\n
                          PHP bcsub()<\/code> Parameters<\/h3>\n
                            \n
                          1. \n
                            left_operand<\/code> \u2014 The left operand, as a string. <\/p>\n<\/li>\n
                          2. \n
                            right_operand<\/code> \u2014 The right operand, as a string. <\/p>\n<\/li>\n
                          3. \n
                            scale<\/code> \u2014 This optional parameter is used to set the number of digits after the decimal place in the result. If omitted, it will default to the scale set globally with the bcscale()<\/code> function, or fallback to 0 if this has not been set.<\/p>\n<\/li>\n<\/ol>\n
                            PHP bcsub()<\/code> Return Value<\/h3>\n
                            The PHP bcsub()<\/code> function returns the result of the subtraction, as a string.<\/p>\n
                            PHP bcsub()<\/code> Working Examples<\/h3>\n
                            1. bcsub() example<\/h4>\n
                            <?php\n$a = '1.234';\n$b = '5';\necho bcsub($a, $b);     \/\/ -3\necho bcsub($a, $b, 4);  \/\/ -3.7660\n?><\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"
                            Arbitrary Precision Maths Functions in PHP Function Name Function Description bcadd() Add two arbitrary precision numbers bccomp() Compare two arbitrary precision numbers bcdiv() Divide two arbitrary precision numbers bcmod() Get modulus of an arbitrary precision number bcmul() Multiply two arbitrary precision numbers bcpow() Raise an arbitrary precision number to another bcpowmod() Raise an arbitrary precision […]<\/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-65","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\/65","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=65"}],"version-history":[{"count":0,"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/posts\/65\/revisions"}],"wp:attachment":[{"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/media?parent=65"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/categories?post=65"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/hellonitish.com\/blog\/wp-json\/wp\/v2\/tags?post=65"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}