# Math.LogMath.LogMath.LogMath.Log Method

## Definition

Returns the logarithm of a specified number.

 Log(Double) Log(Double) Log(Double) Log(Double) Returns the natural (base `e`) logarithm of a specified number. Log(Double, Double) Log(Double, Double) Log(Double, Double) Log(Double, Double) Returns the logarithm of a specified number in a specified base.

## Log(Double)Log(Double)Log(Double)Log(Double)

Returns the natural (base `e`) logarithm of a specified number.

``````public:
static double Log(double d);``````
``public static double Log (double d);``
``static member Log : double -> double``
``Public Shared Function Log (d As Double) As Double``
Parameters
d
Double Double Double Double

The number whose logarithm is to be found.

Returns

One of the values in the following table.

`d` parameter Return value
Positive The natural logarithm of `d`; that is, ln `d`, or log e `d`
Zero NegativeInfinity
Negative NaN
Equal to NaNNaN
Equal to PositiveInfinityPositiveInfinity

### Examples

The following example illustrates the Log method.

``````using System;
public class Example
{
public static void Main()
{
Console.WriteLine("  Evaluate this identity with selected values for X:");
Console.WriteLine("                              ln(x) = 1 / log[X](B)");
Console.WriteLine();

double[] XArgs = { 1.2, 4.9, 9.9, 0.1 };

foreach (double argX in XArgs)
{
// Find natural log of argX.
Console.WriteLine("                      Math.Log({0}) = {1:E16}",
argX, Math.Log(argX));

// Evaluate 1 / log[X](e).
Console.WriteLine("             1.0 / Math.Log(e, {0}) = {1:E16}",
argX, 1.0 / Math.Log(Math.E, argX));
Console.WriteLine();
}
}
}
// This example displays the following output:
//         Evaluate this identity with selected values for X:
//                                     ln(x) = 1 / log[X](B)
//
//                             Math.Log(1.2) = 1.8232155679395459E-001
//                    1.0 / Math.Log(e, 1.2) = 1.8232155679395459E-001
//
//                             Math.Log(4.9) = 1.5892352051165810E+000
//                    1.0 / Math.Log(e, 4.9) = 1.5892352051165810E+000
//
//                             Math.Log(9.9) = 2.2925347571405443E+000
//                    1.0 / Math.Log(e, 9.9) = 2.2925347571405443E+000
//
//                             Math.Log(0.1) = -2.3025850929940455E+000
//                    1.0 / Math.Log(e, 0.1) = -2.3025850929940455E+000
``````
``````Module Example
Sub Main()
Console.WriteLine( _
"  Evaluate this identity with selected values for X:")
Console.WriteLine("                              ln(x) = 1 / log[X](B)")
Console.WriteLine()

Dim XArgs() As Double = { 1.2, 4.9, 9.9, 0.1 }

For Each argX As Double In XArgs
' Find natural log of argX.
Console.WriteLine("                      Math.Log({0}) = {1:E16}", _
argX, Math.Log(argX))

' Evaluate 1 / log[X](e).
Console.WriteLine("             1.0 / Math.Log(e, {0}) = {1:E16}", _
argX, 1.0 / Math.Log(Math.E, argX))
Console.WriteLine()
Next
End Sub
End Module
' This example displays the following output:
'         Evaluate this identity with selected values for X:
'                                     ln(x) = 1 / log[X](B)
'
'                             Math.Log(1.2) = 1.8232155679395459E-001
'                    1.0 / Math.Log(e, 1.2) = 1.8232155679395459E-001
'
'                             Math.Log(4.9) = 1.5892352051165810E+000
'                    1.0 / Math.Log(e, 4.9) = 1.5892352051165810E+000
'
'                             Math.Log(9.9) = 2.2925347571405443E+000
'                    1.0 / Math.Log(e, 9.9) = 2.2925347571405443E+000
'
'                             Math.Log(0.1) = -2.3025850929940455E+000
'                    1.0 / Math.Log(e, 0.1) = -2.3025850929940455E+000
``````

### Remarks

Parameter `d` is specified as a base 10 number.

## Log(Double, Double)Log(Double, Double)Log(Double, Double)Log(Double, Double)

Returns the logarithm of a specified number in a specified base.

``````public:
static double Log(double a, double newBase);``````
``public static double Log (double a, double newBase);``
``static member Log : double * double -> double``
``Public Shared Function Log (a As Double, newBase As Double) As Double``
Parameters
a
Double Double Double Double

The number whose logarithm is to be found.

newBase
Double Double Double Double

The base of the logarithm.

Returns

One of the values in the following table. (+Infinity denotes PositiveInfinity, -Infinity denotes NegativeInfinity, and NaN denotes NaN.)

`a``newBase` Return value
`a`> 0 (0 <`newBase`< 1) -or-(`newBase`> 1) lognewBase(a)
`a`< 0 (any value) NaN
(any value) `newBase`< 0 NaN
`a` != 1 `newBase` = 0 NaN
`a` != 1 `newBase` = +Infinity NaN
`a` = NaN (any value) NaN
(any value) `newBase` = NaN NaN
(any value) `newBase` = 1 NaN
`a` = 0 0 <`newBase`< 1 +Infinity
`a` = 0 `newBase`> 1 -Infinity
`a` = +Infinity 0 <`newBase`< 1 -Infinity
`a` = +Infinity `newBase`> 1 +Infinity
`a` = 1 `newBase` = 0 0
`a` = 1 `newBase` = +Infinity 0

### Examples

The following example uses Log to evaluate certain logarithmic identities for selected values.

``````// Example for the Math::Log( double ) and Math::Log( double, double ) methods.
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( "\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] == ln[X] / ln[B].
Console::WriteLine( "         Math::Log({1}) / Math::Log({0}) == {2:E16}", argB, argX, Math::Log( argX ) / Math::Log( argB ) );

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

void main()
{
Console::WriteLine( "This example of Math::Log( double ) and "
"Math::Log( double, 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] == ln[X] / ln[B]" );
Console::WriteLine( "   log(B)[X] == log(B)[e] * ln[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 ) and Math::Log( double, 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] == ln[X] / ln[B]
log(B)[X] == log(B)[e] * ln[X]

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

Math::Log(4.9, 1.2) == 8.7166610085093179E+000
1.0 / Math::Log(1.2, 4.9) == 8.7166610085093161E+000
Math::Log(4.9) / Math::Log(1.2) == 8.7166610085093179E+000
Math::Log(Math::E, 1.2) * Math::Log(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::Log(9.9) / Math::Log(4.9) == 1.4425396251981288E+000
Math::Log(Math::E, 4.9) * Math::Log(9.9) == 1.4425396251981288E+000

Math::Log(0.1, 9.9) == -1.0043839404494075E+000
1.0 / Math::Log(9.9, 0.1) == -1.0043839404494075E+000
Math::Log(0.1) / Math::Log(9.9) == -1.0043839404494075E+000
Math::Log(Math::E, 9.9) * Math::Log(0.1) == -1.0043839404494077E+000
*/
``````
``````// Example for the Math.Log( double ) and Math.Log( double, double ) methods.
using System;

class LogDLogDD
{
public static void Main()
{
Console.WriteLine(
"This example of Math.Log( double ) and " +
"Math.Log( double, 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] == ln[X] / ln[B]" );
Console.WriteLine( "   log(B)[X] == log(B)[e] * ln[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] == ln[X] / ln[B].
Console.WriteLine(
"        Math.Log({1}) / Math.Log({0}) == {2:E16}",
argB, argX, Math.Log(argX) / Math.Log(argB) );

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

/*
This example of Math.Log( double ) and Math.Log( double, 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] == ln[X] / ln[B]
log(B)[X] == log(B)[e] * ln[X]

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

Math.Log(4.9, 1.2) == 8.7166610085093179E+000
1.0 / Math.Log(1.2, 4.9) == 8.7166610085093161E+000
Math.Log(4.9) / Math.Log(1.2) == 8.7166610085093179E+000
Math.Log(Math.E, 1.2) * Math.Log(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.Log(9.9) / Math.Log(4.9) == 1.4425396251981288E+000
Math.Log(Math.E, 4.9) * Math.Log(9.9) == 1.4425396251981288E+000

Math.Log(0.1, 9.9) == -1.0043839404494075E+000
1.0 / Math.Log(9.9, 0.1) == -1.0043839404494075E+000
Math.Log(0.1) / Math.Log(9.9) == -1.0043839404494075E+000
Math.Log(Math.E, 9.9) * Math.Log(0.1) == -1.0043839404494077E+000
*/
``````
``````' Example for the Math.Log( Double ) and Math.Log( Double, Double ) methods.
Imports System
Imports Microsoft.VisualBasic

Module LogDLogDD

Sub Main()
Console.WriteLine( _
"This example of Math.Log( Double ) and " + _
"Math.Log( Double, 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] = ln[X] / ln[B]")
Console.WriteLine("   log(B)[X] = log(B)[e] * ln[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] = ln[X] / ln[B].
Console.WriteLine( _
"        Math.Log({1}) / Math.Log({0}) = {2:E16}", _
argB, argX, Math.Log(argX) / Math.Log(argB))

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

End Sub 'UseBaseAndArg
End Module 'LogDLogDD

' This example of Math.Log( Double ) and Math.Log( Double, 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] = ln[X] / ln[B]
'    log(B)[X] = log(B)[e] * ln[X]
'
'                    Math.Log(1.2, 0.1) = -7.9181246047624818E-002
'              1.0 / Math.Log(0.1, 1.2) = -7.9181246047624818E-002
'         Math.Log(1.2) / Math.Log(0.1) = -7.9181246047624818E-002
' Math.Log(Math.E, 0.1) * Math.Log(1.2) = -7.9181246047624804E-002
'
'                    Math.Log(4.9, 1.2) = 8.7166610085093179E+000
'              1.0 / Math.Log(1.2, 4.9) = 8.7166610085093161E+000
'         Math.Log(4.9) / Math.Log(1.2) = 8.7166610085093179E+000
' Math.Log(Math.E, 1.2) * Math.Log(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.Log(9.9) / Math.Log(4.9) = 1.4425396251981288E+000
' Math.Log(Math.E, 4.9) * Math.Log(9.9) = 1.4425396251981288E+000
'
'                    Math.Log(0.1, 9.9) = -1.0043839404494075E+000
'              1.0 / Math.Log(9.9, 0.1) = -1.0043839404494075E+000
'         Math.Log(0.1) / Math.Log(9.9) = -1.0043839404494075E+000
' Math.Log(Math.E, 9.9) * Math.Log(0.1) = -1.0043839404494077E+000
``````