This topic has not yet been rated - Rate this topic

# Math.Log10 Method

.NET Framework 1.1

Returns the base 10 logarithm of a specified number.

```[Visual Basic]
Public Shared Function Log10( _
ByVal d As Double _
) As Double
[C#]
public static double Log10(
double d
);
[C++]
public: static double Log10(
double d
);
[JScript]
public static function Log10(
d : double
) : double;```

#### Parameters

d
A number whose logarithm is to be found.

#### Return Value

Sign of d Returns
Positive The base 10 log of d; that is, log10 d.
Zero NegativeInfinity
Negative NaN

If d is equal to NaN, thsi method returns NaN. If d is equal to PositiveInfinity, this method returns PositiveInfinity.

#### Remarks

Parameter d is specified as a base 10 number.

#### Example

[Visual Basic, C#, C++] The following example uses Log10 to evaluate certain logarithmic identities for selected values.

```[Visual Basic]
' Example for the Math.Log( Double, Double )and Math.Log10( Double ) methods.
Imports System
Imports Microsoft.VisualBasic

Module LogDDLog10

Sub Main()
Console.WriteLine( _
"This example of Math.Log( Double, Double ) " + _
"and Math.Log10( Double )" & vbCrLf & _
"generates the following output." & vbCrLf)
Console.WriteLine( _
"Evaluate these identities with " & _
"selected values for X and B (base):")
Console.WriteLine("   log(B)[X] = 1 / log(X)[B]")
Console.WriteLine("   log(B)[X] = log(10)[X] / log(10)[B]")
Console.WriteLine("   log(B)[X] = log(B)[10] * log(10)[X]")

UseBaseAndArg(0.1, 1.2)
UseBaseAndArg(1.2, 4.9)
UseBaseAndArg(4.9, 9.9)
UseBaseAndArg(9.9, 0.1)
End Sub 'Main

' Evaluate logarithmic identities that are functions of two arguments.
Sub UseBaseAndArg(argB As Double, argX As Double)

' Evaluate log(B)[X] = 1 / log(X)[B].
Console.WriteLine( _
vbCrLf & "                   Math.Log({1}, {0}) = {2:E16}" + _
vbCrLf & "             1.0 / Math.Log({0}, {1}) = {3:E16}", _
argB, argX, Math.Log(argX, argB), _
1.0 / Math.Log(argB, argX))

' Evaluate log(B)[X] = log(10)[X] / log(10)[B].
Console.WriteLine( _
"    Math.Log10({1}) / Math.Log10({0}) = {2:E16}", _
argB, argX, Math.Log10(argX) / Math.Log10(argB))

' Evaluate log(B)[X] = log(B)[10] * log(10)[X].
Console.WriteLine( _
"Math.Log(10.0, {0}) * Math.Log10({1}) = {2:E16}", _
argB, argX, Math.Log(10.0, argB) * Math.Log10(argX))

End Sub 'UseBaseAndArg
End Module 'LogDDLog10

' This example of Math.Log( Double, Double ) and Math.Log10( Double )
' generates the following output.
'
' Evaluate these identities with selected values for X and B (base):
'    log(B)[X] = 1 / log(X)[B]
'    log(B)[X] = log(10)[X] / log(10)[B]
'    log(B)[X] = log(B)[10] * log(10)[X]
'
'                    Math.Log(1.2, 0.1) = -7.9181246047624818E-002
'              1.0 / Math.Log(0.1, 1.2) = -7.9181246047624818E-002
'     Math.Log10(1.2) / Math.Log10(0.1) = -7.9181246047624818E-002
' Math.Log(10.0, 0.1) * Math.Log10(1.2) = -7.9181246047624831E-002
'
'                    Math.Log(4.9, 1.2) = 8.7166610085093179E+000
'              1.0 / Math.Log(1.2, 4.9) = 8.7166610085093161E+000
'     Math.Log10(4.9) / Math.Log10(1.2) = 8.7166610085093179E+000
' Math.Log(10.0, 1.2) * Math.Log10(4.9) = 8.7166610085093179E+000
'
'                    Math.Log(9.9, 4.9) = 1.4425396251981288E+000
'              1.0 / Math.Log(4.9, 9.9) = 1.4425396251981288E+000
'     Math.Log10(9.9) / Math.Log10(4.9) = 1.4425396251981288E+000
' Math.Log(10.0, 4.9) * Math.Log10(9.9) = 1.4425396251981291E+000
'
'                    Math.Log(0.1, 9.9) = -1.0043839404494075E+000
'              1.0 / Math.Log(9.9, 0.1) = -1.0043839404494075E+000
'     Math.Log10(0.1) / Math.Log10(9.9) = -1.0043839404494077E+000
' Math.Log(10.0, 9.9) * Math.Log10(0.1) = -1.0043839404494077E+000

[C#]
// Example for the Math.Log( double, double ) and Math.Log10( double ) methods.
using System;

class LogDDLog10
{
public static void Main()
{
Console.WriteLine(
"This example of Math.Log( double, double ) " +
"and Math.Log10( double )\n" +
"generates the following output.\n" );
Console.WriteLine(
"Evaluate these identities with " +
"selected values for X and B (base):" );
Console.WriteLine( "   log(B)[X] == 1 / log(X)[B]" );
Console.WriteLine( "   log(B)[X] == log(10)[X] / log(10)[B]" );
Console.WriteLine( "   log(B)[X] == log(B)[10] * log(10)[X]" );

UseBaseAndArg(0.1, 1.2);
UseBaseAndArg(1.2, 4.9);
UseBaseAndArg(4.9, 9.9);
UseBaseAndArg(9.9, 0.1);
}

// Evaluate logarithmic identities that are functions of two arguments.
static void UseBaseAndArg(double argB, double argX)
{
// Evaluate log(B)[X] == 1 / log(X)[B].
Console.WriteLine(
"\n                   Math.Log({1}, {0}) == {2:E16}" +
"\n             1.0 / Math.Log({0}, {1}) == {3:E16}",
argB, argX, Math.Log(argX, argB),
1.0 / Math.Log(argB, argX) );

// Evaluate log(B)[X] == log(10)[X] / log(10)[B].
Console.WriteLine(
"    Math.Log10({1}) / Math.Log10({0}) == {2:E16}",
argB, argX, Math.Log10(argX) / Math.Log10(argB) );

// Evaluate log(B)[X] == log(B)[10] * log(10)[X].
Console.WriteLine(
"Math.Log(10.0, {0}) * Math.Log10({1}) == {2:E16}",
argB, argX, Math.Log(10.0, argB) * Math.Log10(argX) );
}
}

/*
This example of Math.Log( double, double ) and Math.Log10( double )
generates the following output.

Evaluate these identities with selected values for X and B (base):
log(B)[X] == 1 / log(X)[B]
log(B)[X] == log(10)[X] / log(10)[B]
log(B)[X] == log(B)[10] * log(10)[X]

Math.Log(1.2, 0.1) == -7.9181246047624818E-002
1.0 / Math.Log(0.1, 1.2) == -7.9181246047624818E-002
Math.Log10(1.2) / Math.Log10(0.1) == -7.9181246047624818E-002
Math.Log(10.0, 0.1) * Math.Log10(1.2) == -7.9181246047624831E-002

Math.Log(4.9, 1.2) == 8.7166610085093179E+000
1.0 / Math.Log(1.2, 4.9) == 8.7166610085093161E+000
Math.Log10(4.9) / Math.Log10(1.2) == 8.7166610085093179E+000
Math.Log(10.0, 1.2) * Math.Log10(4.9) == 8.7166610085093179E+000

Math.Log(9.9, 4.9) == 1.4425396251981288E+000
1.0 / Math.Log(4.9, 9.9) == 1.4425396251981288E+000
Math.Log10(9.9) / Math.Log10(4.9) == 1.4425396251981288E+000
Math.Log(10.0, 4.9) * Math.Log10(9.9) == 1.4425396251981291E+000

Math.Log(0.1, 9.9) == -1.0043839404494075E+000
1.0 / Math.Log(9.9, 0.1) == -1.0043839404494075E+000
Math.Log10(0.1) / Math.Log10(9.9) == -1.0043839404494077E+000
Math.Log(10.0, 9.9) * Math.Log10(0.1) == -1.0043839404494077E+000
*/

[C++]
// Example for the Math::Log( double, double ) and Math::Log10( double ) methods.
#using <mscorlib.dll>
using namespace System;

// Evaluate logarithmic identities that are functions of two arguments.
void UseBaseAndArg(double argB, double argX)
{
// Evaluate log(B)[X] == 1 / log(X)[B].
Console::WriteLine(
S"\n                    Math::Log({1}, {0}) == {2:E16}"
S"\n              1.0 / Math::Log({0}, {1}) == {3:E16}",
__box(argB), __box(argX),
__box(Math::Log(argX, argB)),
__box(1.0 / Math::Log(argB, argX)) );

// Evaluate log(B)[X] == log(10)[X] / log(10)[B].
Console::WriteLine(
S"    Math::Log10({1}) / Math::Log10({0}) == {2:E16}",
__box(argB), __box(argX),
__box(Math::Log10(argX) / Math::Log10(argB)) );

// Evaluate log(B)[X] == log(B)[10] * log(10)[X].
Console::WriteLine(
S"Math::Log(10.0, {0}) * Math::Log10({1}) == {2:E16}",
__box(argB), __box(argX),
__box(Math::Log(10.0, argB) * Math::Log10(argX)) );
}

void main()
{
Console::WriteLine(
S"This example of Math::Log( double, double ) "
S"and Math::Log10( double )\n"
S"generates the following output.\n" );
Console::WriteLine(
S"Evaluate these identities with "
S"selected values for X and B (base):" );
Console::WriteLine( S"   log(B)[X] == 1 / log(X)[B]" );
Console::WriteLine( S"   log(B)[X] == log(10)[X] / log(10)[B]" );
Console::WriteLine( S"   log(B)[X] == log(B)[10] * log(10)[X]" );

UseBaseAndArg(0.1, 1.2);
UseBaseAndArg(1.2, 4.9);
UseBaseAndArg(4.9, 9.9);
UseBaseAndArg(9.9, 0.1);
}

/*
This example of Math::Log( double, double ) and Math::Log10( double )
generates the following output.

Evaluate these identities with selected values for X and B (base):
log(B)[X] == 1 / log(X)[B]
log(B)[X] == log(10)[X] / log(10)[B]
log(B)[X] == log(B)[10] * log(10)[X]

Math::Log(1.2, 0.1) == -7.9181246047624818E-002
1.0 / Math::Log(0.1, 1.2) == -7.9181246047624818E-002
Math::Log10(1.2) / Math::Log10(0.1) == -7.9181246047624818E-002
Math::Log(10.0, 0.1) * Math::Log10(1.2) == -7.9181246047624831E-002

Math::Log(4.9, 1.2) == 8.7166610085093179E+000
1.0 / Math::Log(1.2, 4.9) == 8.7166610085093161E+000
Math::Log10(4.9) / Math::Log10(1.2) == 8.7166610085093179E+000
Math::Log(10.0, 1.2) * Math::Log10(4.9) == 8.7166610085093179E+000

Math::Log(9.9, 4.9) == 1.4425396251981288E+000
1.0 / Math::Log(4.9, 9.9) == 1.4425396251981288E+000
Math::Log10(9.9) / Math::Log10(4.9) == 1.4425396251981288E+000
Math::Log(10.0, 4.9) * Math::Log10(9.9) == 1.4425396251981291E+000

Math::Log(0.1, 9.9) == -1.0043839404494075E+000
1.0 / Math::Log(9.9, 0.1) == -1.0043839404494075E+000
Math::Log10(0.1) / Math::Log10(9.9) == -1.0043839404494077E+000
Math::Log(10.0, 9.9) * Math::Log10(0.1) == -1.0043839404494077E+000
*/
```

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button in the upper-left corner of the page.

#### Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework, Common Language Infrastructure (CLI) Standard