# Math.Log Metoda

## Definicja

Zwraca wartość logarytmu określonej liczby.Returns the logarithm of a specified number.

## Przeciążenia

 Log(Double) Zwraca logarytm naturalny (podstawowy `e`) podanej liczby.Returns the natural (base `e`) logarithm of a specified number. Log(Double, Double) Zwraca logarytm o podanej liczbie w określonej bazie.Returns the logarithm of a specified number in a specified base.

## Log(Double)

Zwraca logarytm naturalny (podstawowy `e`) podanej liczby.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``

#### Parametry

d
Double

Liczba, której LOGARYTM ma zostać znaleziony.The number whose logarithm is to be found.

#### Zwraca

Jedna z wartości w tabeli poniżej.One of the values in the following table.

`d` parametr`d` parameter Wartość zwracanaReturn value
DodatniePositive Logarytm naturalny `d`; to jest, LN `d`lub log e `d`The natural logarithm of `d`; that is, ln `d`, or log e `d`
ZeroZero NegativeInfinity
UjemneNegative NaN
Równe NaNEqual to NaNNaN
Równe PositiveInfinityEqual to PositiveInfinityPositiveInfinity

Poniższy przykład ilustruje metodę Log.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
``````

### Uwagi

Parametr `d` jest określony jako numer podstawowy 10.Parameter `d` is specified as a base 10 number.

## Log(Double, Double)

Zwraca logarytm o podanej liczbie w określonej bazie.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``

#### Parametry

a
Double

Liczba, której LOGARYTM ma zostać znaleziony.The number whose logarithm is to be found.

newBase
Double

Podstawa logarytmu.The base of the logarithm.

#### Zwraca

Jedna z wartości w tabeli poniżej.One of the values in the following table. (+ Nieskończoność oznacza PositiveInfinity,-nieskończoności oznacza NegativeInfinityi NaN oznacza NaN).(+Infinity denotes PositiveInfinity, -Infinity denotes NegativeInfinity, and NaN denotes NaN.)

`a``newBase` Wartość zwracanaReturn value
`a`> 0`a`> 0 (0 <`newBase`< 1)-lub-(`newBase`> 1)(0 <`newBase`< 1) -or-(`newBase`> 1) lognewBase (a)lognewBase(a)
`a`< 0`a`< 0 (dowolna wartość)(any value) {1&gt;NaN&lt;1}NaN
(dowolna wartość)(any value) `newBase`< 0`newBase`< 0 {1&gt;NaN&lt;1}NaN
`a` != 1`a` != 1 `newBase` = 0`newBase` = 0 {1&gt;NaN&lt;1}NaN
`a` != 1`a` != 1 `newBase` = + nieskończoność`newBase` = +Infinity {1&gt;NaN&lt;1}NaN
`a` = NaN`a` = NaN (dowolna wartość)(any value) {1&gt;NaN&lt;1}NaN
(dowolna wartość)(any value) `newBase` = NaN`newBase` = NaN {1&gt;NaN&lt;1}NaN
(dowolna wartość)(any value) `newBase` = 1`newBase` = 1 {1&gt;NaN&lt;1}NaN
`a` = 0`a` = 0 0 <`newBase`< 10 <`newBase`< 1 + Nieskończoność+Infinity
`a` = 0`a` = 0 `newBase`> 1`newBase`> 1 -Nieskończoność-Infinity
`a` = + nieskończoność`a` = +Infinity 0 <`newBase`< 10 <`newBase`< 1 -Nieskończoność-Infinity
`a` = + nieskończoność`a` = +Infinity `newBase`> 1`newBase`> 1 + Nieskończoność+Infinity
`a` = 1`a` = 1 `newBase` = 0`newBase` = 0 00
`a` = 1`a` = 1 `newBase` = + nieskończoność`newBase` = +Infinity 00

Poniższy przykład używa Log do szacowania niektórych tożsamości logarytmicznych dla wybranych wartości.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.
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
``````