Export (0) Print
Expand All
This topic has not yet been rated - Rate this topic

Math.Log10 Method

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 Language Filter 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

See Also

Math Class | Math Members | System Namespace

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.