Math.Log Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.Extensions.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Vrátí logaritmus zadaného čísla.

Přetížení

Log(Double, Double)	Vrátí logaritmus zadaného čísla v zadaném základu.
Log(Double)	Vrátí přirozený (základní `e`) logaritmus zadaného čísla.

Log(Double, Double)

Zdroj:: Math.cs

Zdroj:: Math.cs

Zdroj:: Math.cs

Vrátí logaritmus zadaného čísla v zadaném základu.

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

Číslo, jehož logaritmus se má najít.

newBase: Double

Základ logaritmu.

Návraty

Double

Jedna z hodnot v následující tabulce. (+Infinity označuje PositiveInfinity, -Infinity označuje NegativeInfinitya NaN označuje NaN.)

`a`	`newBase`	Vrácená hodnota
`a` > 0	(0 <`newBase`< 1) –nebo (`newBase`> 1)	lognewBase(a)
`a` < 0	(libovolná hodnota)	Není číslo
(libovolná hodnota)	`newBase` < 0	Není číslo
`a` != 1	`newBase` = 0	Není číslo
`a` != 1	`newBase` = +Nekonečno	Není číslo
`a` = NaN	(libovolná hodnota)	Není číslo
(libovolná hodnota)	`newBase` = NaN	Není číslo
(libovolná hodnota)	`newBase` = 1	Není číslo
`a` = 0	0 <`newBase`< 1	+Nekonečno
`a` = 0	`newBase` > 1	-Nekonečno
`a` = +Nekonečno	0 <`newBase`< 1	-Nekonečno
`a` = +Nekonečno	`newBase` > 1	+Nekonečno
`a` = 1	`newBase` = 0	0
`a` = 1	`newBase` = +Nekonečno	0

Příklady

Následující příklad používá Log k vyhodnocení určitých logaritmických identit pro vybrané hodnoty.

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

Poznámky

Tato metoda volá základní modul runtime jazyka C a přesný výsledek nebo platný vstupní rozsah se může v různých operačních systémech nebo architekturách lišit.

Platí pro

Log(Double)

Zdroj:: Math.cs

Zdroj:: Math.cs

Zdroj:: Math.cs

Vrátí přirozený (základní e) logaritmus zadaného čísla.

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

Číslo, jehož logaritmus se má najít.

Návraty

Double

Jedna z hodnot v následující tabulce.

`d` Parametr	Vrácená hodnota
Kladné	Přirozený logaritmus `d`; tj. ln `d`, nebo log e `d`
Žádnou	NegativeInfinity
Záporný	NaN
Rovná se NaN	NaN
Rovná se PositiveInfinity	PositiveInfinity

Příklady

Následující příklad ukazuje metodu Log .

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

Poznámky

Parametr d je určen jako základní číslo 10.

Tato metoda volá základní modul runtime jazyka C a přesný výsledek nebo platný vstupní rozsah se může v různých operačních systémech nebo architekturách lišit.

Viz také

Platí pro

Sdílet prostřednictvím

Math.Log Metoda

Definice

Přetížení

Log(Double, Double)

Parametry

Návraty

Příklady

Poznámky

Platí pro

Log(Double)

Parametry

Návraty

Příklady

Poznámky

Viz také

Platí pro

Další materiály