Math.Log Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Devuelve el logaritmo de un número especificado.

Sobrecargas

Log(Double, Double)	Devuelve el logaritmo de un número especificado en una base determinada.
Log(Double)	Devuelve el logaritmo natural (en base e) de un número especificado.

Log(Double, Double)

Source:

Math.cs

Devuelve el logaritmo de un número especificado en una base determinada.

C#

public static double Log (double a, double newBase);

Parámetros

a

Double

Número cuyo logaritmo se va a calcular.

newBase

Double

Base del logaritmo.

Devoluciones

Double

Uno de los valores de la tabla siguiente. (+Infinito denota PositiveInfinity, -Infinito denota NegativeInfinity y NaN denota NaN)

a	newBase	Valor devuelto
a > 0	(0 <newBase< 1) -o- (newBase> 1)	lognewBase(a)
a < 0	(cualquier valor)	NaN
(cualquier valor)	newBase < 0	NaN
a != 1	newBase = 0	NaN
a != 1	newBase = +Infinito	NaN
a = NaN	(cualquier valor)	NaN
(cualquier valor)	newBase = NaN	NaN
(cualquier valor)	newBase = 1	NaN
a = 0	0 <newBase< 1	+Infinito
a = 0	newBase > 1	-Infinity
a = +Infinito	0 <newBase< 1	-Infinity
a = +Infinito	newBase > 1	+Infinito
a = 1	newBase = 0	0
a = 1	newBase = +Infinito	0

Ejemplos

En el ejemplo siguiente se usa Log para evaluar determinadas identidades logarítmicas para los valores seleccionados.

C#

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

Comentarios

Este método llama al entorno de ejecución de C subyacente y el resultado exacto o el intervalo de entrada válido pueden diferir entre diferentes sistemas operativos o arquitecturas.

Log(Double)

Source:

Math.cs

Devuelve el logaritmo natural (en base e) de un número especificado.

C#

public static double Log (double d);

Parámetros

d

Double

Número cuyo logaritmo se va a calcular.

Devoluciones

Double

Uno de los valores de la tabla siguiente.

Parámetro d	Valor devuelto
Positivo	El algoritmo natural de d; es decir, ln d o log e d
Cero	NegativeInfinity
Negativo	NaN
Igual a NaN	NaN
Igual a PositiveInfinity	PositiveInfinity

Ejemplos

El ejemplo siguiente ilustra la Log método.

C#

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

Comentarios

El parámetro d se especifica como un número base 10.

Este método llama al entorno de ejecución de C subyacente y el resultado exacto o el intervalo de entrada válido pueden diferir entre diferentes sistemas operativos o arquitecturas.

Este método llama al entorno de ejecución de C subyacente y el resultado exacto o el intervalo de entrada válido pueden diferir entre diferentes sistemas operativos o arquitecturas.

Consulte también

• E
• Exp(Double)