Math.Log Method

Reference

Definition

Namespace:: System

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Returns the logarithm of a specified number.

Overloads

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

Log(Double, Double)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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

The number whose logarithm is to be found.

newBase: Double

The base of the logarithm.

Returns

Double

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.
open System

// Evaluate logarithmic identities that are functions of two arguments.
let useBaseAndArg argB argX =
    // Evaluate log(B)[X] == 1 / log(X)[B].
    printfn $"""
                   Math.Log({argX}, {argB}) == {Math.Log(argX, argB):E16}
             1.0 / Math.Log({argB}, {argX}) == {1. / Math.Log(argB, argX):E16}"""

    // Evaluate log(B)[X] == ln[X] / ln[B].
    printfn $"        Math.Log({argX}) / Math.Log({argB}) == {Math.Log argX / Math.Log argB:E16}"

    // Evaluate log(B)[X] == log(B)[e] * ln[X].
    printfn $"Math.Log(Math.E, {argB}) * Math.Log({argX}) == {Math.Log(Math.E, argB) * Math.Log argX:E16}"


printfn
    """This example of Math.Log( double ) and Math.Log( double, double )
generates the following output.

printfn "Evaluate these identities with selected values for X and B (base):"""
printfn "   log(B)[X] == 1 / log(X)[B]"
printfn "   log(B)[X] == ln[X] / ln[B]" 
printfn "   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.
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
       
    ' 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
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

Remarks

This method calls into the underlying C runtime, and the exact result or valid input range may differ between different operating systems or architectures.

Applies to

Log(Double)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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

The number whose logarithm is to be found.

Returns

Double

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 NaN	NaN
Equal to PositiveInfinity	PositiveInfinity

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

open System

printfn "  Evaluate this identity with selected values for X:"
printfn "                              ln(x) = 1 / log[X](B)\n"

let XArgs = [| 1.2; 4.9; 9.9; 0.1 |]

for argX in XArgs do
    // Find natural log of argX.
    // The F# log function may be used instead
    printfn $"                      Math.Log({argX}) = {Math.Log argX:E16}"

    // Evaluate 1 / log[X](e).
    printfn $"             1.0 / Math.Log(e, {argX}) = {1. / Math.Log(Math.E, argX):E16}\n"

// 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.

This method calls into the underlying C runtime, and the exact result or valid input range may differ between different operating systems or architectures.

Applies to

Jaa

Math.Log Method

Definition

Overloads

Log(Double, Double)

Parameters

Returns

Examples

Remarks

Applies to

Log(Double)

Parameters

Returns

Examples

Remarks

See also

Applies to

Lisäresursseja