log1p
For those interested. Works with older than 4.3 versions.
<?php
function byteConvert($bytes)
{
$s = array('B', 'Kb', 'MB', 'GB', 'TB', 'PB');
$e = floor(log($bytes)/log(1024));
return sprintf('%.2f '.$s[$e], ($bytes/pow(1024, floor($e))));
}
?>
log
(PHP 4, PHP 5)
log — Natural logarithm
Description
float log
( float
$arg
[, float $base = M_E
] )
If the optional base parameter is specified,
log() returns logbase
arg, otherwise log()
returns the natural logarithm of arg.
Parameters
-
arg -
The value to calculate the logarithm for
-
base -
The optional logarithmic base to use (defaults to 'e' and so to the natural logarithm).
Return Values
The logarithm of arg to
base, if given, or the
natural logarithm.
Changelog
| Version | Description |
|---|---|
| Since 4.3.0 |
The optional parameter base became available.
For older versions you can calculate the logarithm in base b
of a number n, but using the mathematical identity:
logb(n) = log(n)/log(b), where log is the
neperian (or natural) logarithm.
|
add a note
User Contributed Notes
log
olafurw [at] gmail.com
04-Nov-2008 04:56
dingus_76 at hotmail dot com
15-May-2008 07:41
well i been pulling my hair out trying to get log to work with big numbers and i ended up writing a bclog function so to save everyone else the stress here it is
<?php
function bclog($X,$base=10,$decimalplace=12){
$integer_value=0;
while($X < 1){
$integer_value = $integer_value - 1 ;
$X = bcmul($X , base);
}
while($X >= $base){
$integer_value = $integer_value + 1;
$X = bcdiv($X , $base );
}
$decimal_fraction = 0.0;
$partial = 1.0;
# Replace X with X to the 10th power
$X = bcpow($X , 10);
while($decimalplace > 0){
$partial = bcdiv($partial , 10);
$digit=0;
while($X >= $base){
$digit = $digit + 1;
$X = bcdiv($X , $base);
}
$decimal_fraction = bcadd($decimal_fraction , bcmul($digit , $partial));
# Replace X with X to the 10th power
$X = bcpow($X , 10);
$decimalplace = $decimalplace - 1 ;
}
return $integer_value + $decimal_fraction ;
}
?>
Ulf Wostner
06-Aug-2006 05:56
<?php
#--------------------------------------------------------
# How many digits does an integer have?
#--------------------------------------------------------
function digit_count($n, $base=10) {
if($n == 0) return 1;
if($base == 10) {
# using the built-in log10(x)
# might be more accurate than log(x)/log(10).
return 1 + floor(log10(abs($n)));
}else{
# here logB(x) = log(x)/log(B) will have to do.
return 1 + floor(log(abs($n))/ log($base));
}
}
# Example: How many decimal digits for 2 to the power 24?
echo digit_count(pow(2, 24));
# Example: How many bits to write 1 billion in binary, last century?
if($country_code == 'US') echo digit_count(pow(10, 9), 2);
if($country_code == 'UK') echo digit_count(pow(10, 12), 2);
#--------------------------------------------------------
# Using log to format columns.
#--------------------------------------------------------
# Suppose we have a dynamically generated list of integers,
# and want to present them as a table. The use of log10 in
# our digit_count helps calculate the proper format string.
function print_list_of_ints($ints, $line_width=40) {
# Apply our digit_count to the max int among ints.
$field_width = 2 + digit_count(max($ints));
# Create format string for printf.
$format = "%${field_width}d";
$ints_per_line = floor($line_width/$field_width);
$border = str_repeat("-", $ints_per_line * $field_width);
echo "\n$border\n";
foreach($ints as $count => $int) {
if( $count and ($count % $ints_per_line == 0)) echo "\n";
printf($format, $int);
}
echo "\n$border\n";
}
# To generate an example, here is a basic function
# returning a list of (pseudo) random numbers.
function rands($how_many) {
for($i=0; $i < $how_many; $i++) $rands[] = rand();
return $rands;
}
# Example: A list of random ints dynamically formatted into columns.
print_list_of_ints(rands(11));
/* Sample output. Numbers and fonts vary. Visualize monospace!
------------------------------------
1093146637 244503173 1346204527
638304372 140216732 1054707210
573915416 1728677954 2038899669
534854768 12674586
------------------------------------
*/
?>
mcmeijer at yahoo dot com
03-Feb-2005 07:22
$val = 1000000
$val2 = floor(log($val,10)) gives a value of 5 for $val2 and not 6 as expected.
$val2 = floor(log10($val)) gives the correct value.
c0x at mail dot ru
19-Sep-2004 03:08
more general version, works fine on negative, very big ($value > 1E+18) and very small ($value < 1E-18) numbers.
function expn($value, $prec = 3, $base = 1000, $prefix = '') {
$e = array('a', 'f', 'p', 'n', 'u', 'm', '', 'k', 'M', 'G', 'T', 'P', 'E');
$p = min(max(floor(log(abs($value), $base)), -6), 6);
return round((float)$value / pow($base, $p), $prec) . $prefx . $e[$p + 6];
}
admin at worldtakeover dot tk
20-Jun-2004 01:06
In regards to the note about log in base 10 and the round() function. You need to use floor() instead of round() to find out the order of magnitude. That way, you don't have to worry about subtracting 0.5 or whatever.
mightye (at) mightye.org
06-Feb-2003 12:02
A minor warning:
in PHP < 4.3.0, in order to get the log base 10 of a number, you have to do:
$log10 = log($n)/log(10);
If you want a whole number (to identify the order of magnitude), and you typecast $log10 to (int), you may not get what you expect:
(int)(log(1000)/log(10)) = 2
(log(1000)/log(10)) = 3 (float with no displayed decimal places)
The mathematical error in this causes the typecast to round the result down, even though the error runs out to so many decimal places that it is not displayed, and the float value looks like a whole number. Instead you may need to do:
round(log($n)/log(10)-0.5,0);
This will give you the order of magnitude of your number.
Presumably in PHP 4.3.0+, a similar result may occur.