Math.Exp(Double) Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Devuelve e elevado a la potencia especificada.
public:
static double Exp(double d);public static double Exp (double d);static member Exp : double -> doublePublic Shared Function Exp (d As Double) As DoubleParámetros
- d
- Double
Número que especifica una potencia.
Devoluciones
Número e elevado a la potencia d. Si d es igual que NaN o PositiveInfinity, se devuelve ese valor. Si d es igual que NegativeInfinity, se devuelve 0.
Ejemplos
En el ejemplo siguiente se usa Exp para evaluar determinadas identidades exponenciales y logarítmicas para los valores seleccionados.
// Example for the Math::Exp( double ) method.
using namespace System;
// Evaluate logarithmic/exponential identity with a given argument.
void UseLnExp( double arg )
{
// Evaluate e ^ ln(X) == ln(e ^ X) == X.
Console::WriteLine( "\n Math::Exp(Math::Log({0})) == {1:E16}\n"
" Math::Log(Math::Exp({0})) == {2:E16}", arg, Math::Exp( Math::Log( arg ) ), Math::Log( Math::Exp( arg ) ) );
}
// Evaluate exponential identities that are functions of two arguments.
void UseTwoArgs( double argX, double argY )
{
// Evaluate (e ^ X) * (e ^ Y) == e ^ (X + Y).
Console::WriteLine( "\nMath::Exp({0}) * Math::Exp({1}) == {2:E16}"
"\n Math::Exp({0} + {1}) == {3:E16}", argX, argY, Math::Exp( argX ) * Math::Exp( argY ), Math::Exp( argX + argY ) );
// Evaluate (e ^ X) ^ Y == e ^ (X * Y).
Console::WriteLine( " Math::Pow(Math::Exp({0}), {1}) == {2:E16}"
"\n Math::Exp({0} * {1}) == {3:E16}", argX, argY, Math::Pow( Math::Exp( argX ), argY ), Math::Exp( argX * argY ) );
// Evaluate X ^ Y == e ^ (Y * ln(X)).
Console::WriteLine( " Math::Pow({0}, {1}) == {2:E16}"
"\nMath::Exp({1} * Math::Log({0})) == {3:E16}", argX, argY, Math::Pow( argX, argY ), Math::Exp( argY * Math::Log( argX ) ) );
}
int main()
{
Console::WriteLine( "This example of Math::Exp( double ) "
"generates the following output.\n" );
Console::WriteLine( "Evaluate [e ^ ln(X) == ln(e ^ X) == X] "
"with selected values for X:" );
UseLnExp( 0.1 );
UseLnExp( 1.2 );
UseLnExp( 4.9 );
UseLnExp( 9.9 );
Console::WriteLine( "\nEvaluate these identities with "
"selected values for X and Y:" );
Console::WriteLine( " (e ^ X) * (e ^ Y) == e ^ (X + Y)" );
Console::WriteLine( " (e ^ X) ^ Y == e ^ (X * Y)" );
Console::WriteLine( " X ^ Y == e ^ (Y * ln(X))" );
UseTwoArgs( 0.1, 1.2 );
UseTwoArgs( 1.2, 4.9 );
UseTwoArgs( 4.9, 9.9 );
}
/*
This example of Math::Exp( double ) generates the following output.
Evaluate [e ^ ln(X) == ln(e ^ X) == X] with selected values for X:
Math::Exp(Math::Log(0.1)) == 1.0000000000000001E-001
Math::Log(Math::Exp(0.1)) == 1.0000000000000008E-001
Math::Exp(Math::Log(1.2)) == 1.2000000000000000E+000
Math::Log(Math::Exp(1.2)) == 1.2000000000000000E+000
Math::Exp(Math::Log(4.9)) == 4.9000000000000012E+000
Math::Log(Math::Exp(4.9)) == 4.9000000000000004E+000
Math::Exp(Math::Log(9.9)) == 9.9000000000000004E+000
Math::Log(Math::Exp(9.9)) == 9.9000000000000004E+000
Evaluate these identities with selected values for X and Y:
(e ^ X) * (e ^ Y) == e ^ (X + Y)
(e ^ X) ^ Y == e ^ (X * Y)
X ^ Y == e ^ (Y * ln(X))
Math::Exp(0.1) * Math::Exp(1.2) == 3.6692966676192444E+000
Math::Exp(0.1 + 1.2) == 3.6692966676192444E+000
Math::Pow(Math::Exp(0.1), 1.2) == 1.1274968515793757E+000
Math::Exp(0.1 * 1.2) == 1.1274968515793757E+000
Math::Pow(0.1, 1.2) == 6.3095734448019331E-002
Math::Exp(1.2 * Math::Log(0.1)) == 6.3095734448019344E-002
Math::Exp(1.2) * Math::Exp(4.9) == 4.4585777008251705E+002
Math::Exp(1.2 + 4.9) == 4.4585777008251716E+002
Math::Pow(Math::Exp(1.2), 4.9) == 3.5780924170885260E+002
Math::Exp(1.2 * 4.9) == 3.5780924170885277E+002
Math::Pow(1.2, 4.9) == 2.4433636334442981E+000
Math::Exp(4.9 * Math::Log(1.2)) == 2.4433636334442981E+000
Math::Exp(4.9) * Math::Exp(9.9) == 2.6764450551890982E+006
Math::Exp(4.9 + 9.9) == 2.6764450551891015E+006
Math::Pow(Math::Exp(4.9), 9.9) == 1.1684908531676833E+021
Math::Exp(4.9 * 9.9) == 1.1684908531676829E+021
Math::Pow(4.9, 9.9) == 6.8067718210957060E+006
Math::Exp(9.9 * Math::Log(4.9)) == 6.8067718210956985E+006
*/
// Example for the Math.Exp( double ) method.
using System;
class ExpDemo
{
public static void Main()
{
Console.WriteLine(
"This example of Math.Exp( double ) " +
"generates the following output.\n" );
Console.WriteLine(
"Evaluate [e ^ ln(X) == ln(e ^ X) == X] " +
"with selected values for X:" );
UseLnExp(0.1);
UseLnExp(1.2);
UseLnExp(4.9);
UseLnExp(9.9);
Console.WriteLine(
"\nEvaluate these identities with " +
"selected values for X and Y:" );
Console.WriteLine( " (e ^ X) * (e ^ Y) == e ^ (X + Y)" );
Console.WriteLine( " (e ^ X) ^ Y == e ^ (X * Y)" );
Console.WriteLine( " X ^ Y == e ^ (Y * ln(X))" );
UseTwoArgs(0.1, 1.2);
UseTwoArgs(1.2, 4.9);
UseTwoArgs(4.9, 9.9);
}
// Evaluate logarithmic/exponential identity with a given argument.
static void UseLnExp(double arg)
{
// Evaluate e ^ ln(X) == ln(e ^ X) == X.
Console.WriteLine(
"\n Math.Exp(Math.Log({0})) == {1:E16}\n" +
" Math.Log(Math.Exp({0})) == {2:E16}",
arg, Math.Exp(Math.Log(arg)), Math.Log(Math.Exp(arg)) );
}
// Evaluate exponential identities that are functions of two arguments.
static void UseTwoArgs(double argX, double argY)
{
// Evaluate (e ^ X) * (e ^ Y) == e ^ (X + Y).
Console.WriteLine(
"\nMath.Exp({0}) * Math.Exp({1}) == {2:E16}" +
"\n Math.Exp({0} + {1}) == {3:E16}",
argX, argY, Math.Exp(argX) * Math.Exp(argY),
Math.Exp(argX + argY) );
// Evaluate (e ^ X) ^ Y == e ^ (X * Y).
Console.WriteLine(
" Math.Pow(Math.Exp({0}), {1}) == {2:E16}" +
"\n Math.Exp({0} * {1}) == {3:E16}",
argX, argY, Math.Pow(Math.Exp(argX), argY),
Math.Exp(argX * argY) );
// Evaluate X ^ Y == e ^ (Y * ln(X)).
Console.WriteLine(
" Math.Pow({0}, {1}) == {2:E16}" +
"\nMath.Exp({1} * Math.Log({0})) == {3:E16}",
argX, argY, Math.Pow(argX, argY),
Math.Exp(argY * Math.Log(argX)) );
}
}
/*
This example of Math.Exp( double ) generates the following output.
Evaluate [e ^ ln(X) == ln(e ^ X) == X] with selected values for X:
Math.Exp(Math.Log(0.1)) == 1.0000000000000001E-001
Math.Log(Math.Exp(0.1)) == 1.0000000000000008E-001
Math.Exp(Math.Log(1.2)) == 1.2000000000000000E+000
Math.Log(Math.Exp(1.2)) == 1.2000000000000000E+000
Math.Exp(Math.Log(4.9)) == 4.9000000000000012E+000
Math.Log(Math.Exp(4.9)) == 4.9000000000000004E+000
Math.Exp(Math.Log(9.9)) == 9.9000000000000004E+000
Math.Log(Math.Exp(9.9)) == 9.9000000000000004E+000
Evaluate these identities with selected values for X and Y:
(e ^ X) * (e ^ Y) == e ^ (X + Y)
(e ^ X) ^ Y == e ^ (X * Y)
X ^ Y == e ^ (Y * ln(X))
Math.Exp(0.1) * Math.Exp(1.2) == 3.6692966676192444E+000
Math.Exp(0.1 + 1.2) == 3.6692966676192444E+000
Math.Pow(Math.Exp(0.1), 1.2) == 1.1274968515793757E+000
Math.Exp(0.1 * 1.2) == 1.1274968515793757E+000
Math.Pow(0.1, 1.2) == 6.3095734448019331E-002
Math.Exp(1.2 * Math.Log(0.1)) == 6.3095734448019344E-002
Math.Exp(1.2) * Math.Exp(4.9) == 4.4585777008251705E+002
Math.Exp(1.2 + 4.9) == 4.4585777008251716E+002
Math.Pow(Math.Exp(1.2), 4.9) == 3.5780924170885260E+002
Math.Exp(1.2 * 4.9) == 3.5780924170885277E+002
Math.Pow(1.2, 4.9) == 2.4433636334442981E+000
Math.Exp(4.9 * Math.Log(1.2)) == 2.4433636334442981E+000
Math.Exp(4.9) * Math.Exp(9.9) == 2.6764450551890982E+006
Math.Exp(4.9 + 9.9) == 2.6764450551891015E+006
Math.Pow(Math.Exp(4.9), 9.9) == 1.1684908531676833E+021
Math.Exp(4.9 * 9.9) == 1.1684908531676829E+021
Math.Pow(4.9, 9.9) == 6.8067718210957060E+006
Math.Exp(9.9 * Math.Log(4.9)) == 6.8067718210956985E+006
*/
// Example for the Math.Exp( double ) method.
// The exp function may be used instead.
open System
printfn "This example of Math.Exp( double ) generates the following output.\n"
printfn "Evaluate [e ^ ln(X) = ln(e ^ X) = X] with selected values for X:"
// Evaluate logarithmic/exponential identity with a given argument.
let useLnExp arg =
// Evaluate e ^ ln(X) = ln(e ^ X) = X.
printfn $"\n Math.Exp(Math.Log({arg})) = {Math.Exp(Math.Log arg):E16}\n Math.Log(Math.Exp({arg})) = {Math.Log(Math.Exp arg):E16}"
// Evaluate exponential identities that are functions of two arguments.
let useTwoArgs argX argY =
// Evaluate (e ^ X) * (e ^ Y) = e ^ (X + Y).
printfn $"""
Math.Exp({argX}) * Math.Exp({argY}) = {Math.Exp argX * Math.Exp argY:E16}" +
Math.Exp({argX} + {argY}) = {Math.Exp(argX + argY):E16}"""
// Evaluate (e ^ X) ^ Y = e ^ (X * Y).
printfn $" Math.Pow(Math.Exp({argX}), {argY}) = {Math.Pow(Math.Exp argX, argY):E16}\n Math.Exp({argX} * {argY}) = {Math.Exp(argX * argY):E16}"
// Evaluate X ^ Y = e ^ (Y * ln(X)).
printfn $" Math.Pow({argX}, {argY}) = {Math.Pow(argX, argY):E16}\nMath.Exp({argY} * Math.Log({argX})) = {Math.Exp(argY * Math.Log argX):E16}"
useLnExp 0.1
useLnExp 1.2
useLnExp 4.9
useLnExp 9.9
printfn "\nEvaluate these identities with selected values for X and Y:"
printfn " (e ^ X) * (e ^ Y) = e ^ (X + Y)"
printfn " (e ^ X) ^ Y = e ^ (X * Y)"
printfn " X ^ Y = e ^ (Y * ln(X))"
useTwoArgs 0.1 1.2
useTwoArgs 1.2 4.9
useTwoArgs 4.9 9.9
// This example of Math.Exp( double ) generates the following output.
//
// Evaluate [e ^ ln(X) = ln(e ^ X) = X] with selected values for X:
//
// Math.Exp(Math.Log(0.1)) = 1.0000000000000001E-001
// Math.Log(Math.Exp(0.1)) = 1.0000000000000008E-001
//
// Math.Exp(Math.Log(1.2)) = 1.2000000000000000E+000
// Math.Log(Math.Exp(1.2)) = 1.2000000000000000E+000
//
// Math.Exp(Math.Log(4.9)) = 4.9000000000000012E+000
// Math.Log(Math.Exp(4.9)) = 4.9000000000000004E+000
//
// Math.Exp(Math.Log(9.9)) = 9.9000000000000004E+000
// Math.Log(Math.Exp(9.9)) = 9.9000000000000004E+000
//
// Evaluate these identities with selected values for X and Y:
// (e ^ X) * (e ^ Y) = e ^ (X + Y)
// (e ^ X) ^ Y = e ^ (X * Y)
// X ^ Y = e ^ (Y * ln(X))
//
// Math.Exp(0.1) * Math.Exp(1.2) = 3.6692966676192444E+000
// Math.Exp(0.1 + 1.2) = 3.6692966676192444E+000
// Math.Pow(Math.Exp(0.1), 1.2) = 1.1274968515793757E+000
// Math.Exp(0.1 * 1.2) = 1.1274968515793757E+000
// Math.Pow(0.1, 1.2) = 6.3095734448019331E-002
// Math.Exp(1.2 * Math.Log(0.1)) = 6.3095734448019344E-002
//
// Math.Exp(1.2) * Math.Exp(4.9) = 4.4585777008251705E+002
// Math.Exp(1.2 + 4.9) = 4.4585777008251716E+002
// Math.Pow(Math.Exp(1.2), 4.9) = 3.5780924170885260E+002
// Math.Exp(1.2 * 4.9) = 3.5780924170885277E+002
// Math.Pow(1.2, 4.9) = 2.4433636334442981E+000
// Math.Exp(4.9 * Math.Log(1.2)) = 2.4433636334442981E+000
//
// Math.Exp(4.9) * Math.Exp(9.9) = 2.6764450551890982E+006
// Math.Exp(4.9 + 9.9) = 2.6764450551891015E+006
// Math.Pow(Math.Exp(4.9), 9.9) = 1.1684908531676833E+021
// Math.Exp(4.9 * 9.9) = 1.1684908531676829E+021
// Math.Pow(4.9, 9.9) = 6.8067718210957060E+006
// Math.Exp(9.9 * Math.Log(4.9)) = 6.8067718210956985E+006
' Example for the Math.Exp( Double ) method.
Module ExpDemo
Sub Main()
Console.WriteLine( _
"This example of Math.Exp( Double ) " & _
"generates the following output." & vbCrLf)
Console.WriteLine( _
"Evaluate [e ^ ln(X) == ln(e ^ X) == X] " & _
"with selected values for X:")
UseLnExp(0.1)
UseLnExp(1.2)
UseLnExp(4.9)
UseLnExp(9.9)
Console.WriteLine( vbCrLf & _
"Evaluate these identities with selected values for X and Y:")
Console.WriteLine(" (e ^ X) * (e ^ Y) = e ^ (X + Y)")
Console.WriteLine(" (e ^ X) ^ Y = e ^ (X * Y)")
Console.WriteLine(" X ^ Y = e ^ (Y * ln(X))")
UseTwoArgs(0.1, 1.2)
UseTwoArgs(1.2, 4.9)
UseTwoArgs(4.9, 9.9)
End Sub
' Evaluate logarithmic/exponential identity with a given argument.
Sub UseLnExp(arg As Double)
' Evaluate e ^ ln(X) = ln(e ^ X) = X.
Console.WriteLine( _
vbCrLf & " Math.Exp(Math.Log({0})) = {1:E16}" + _
vbCrLf & " Math.Log(Math.Exp({0})) = {2:E16}", _
arg, Math.Exp(Math.Log(arg)), Math.Log(Math.Exp(arg)))
End Sub
' Evaluate exponential identities that are functions of two arguments.
Sub UseTwoArgs(argX As Double, argY As Double)
' Evaluate (e ^ X) * (e ^ Y) = e ^ (X + Y).
Console.WriteLine( _
vbCrLf & "Math.Exp({0}) * Math.Exp({1}) = {2:E16}" + _
vbCrLf & " Math.Exp({0} + {1}) = {3:E16}", _
argX, argY, Math.Exp(argX) * Math.Exp(argY), _
Math.Exp((argX + argY)))
' Evaluate (e ^ X) ^ Y = e ^ (X * Y).
Console.WriteLine( _
" Math.Pow(Math.Exp({0}), {1}) = {2:E16}" + _
vbCrLf & " Math.Exp({0} * {1}) = {3:E16}", _
argX, argY, Math.Pow(Math.Exp(argX), argY), _
Math.Exp((argX * argY)))
' Evaluate X ^ Y = e ^ (Y * ln(X)).
Console.WriteLine( _
" Math.Pow({0}, {1}) = {2:E16}" + _
vbCrLf & "Math.Exp({1} * Math.Log({0})) = {3:E16}", _
argX, argY, Math.Pow(argX, argY), _
Math.Exp((argY * Math.Log(argX))))
End Sub
End Module 'ExpDemo
' This example of Math.Exp( Double ) generates the following output.
'
' Evaluate [e ^ ln(X) == ln(e ^ X) == X] with selected values for X:
'
' Math.Exp(Math.Log(0.1)) = 1.0000000000000001E-001
' Math.Log(Math.Exp(0.1)) = 1.0000000000000008E-001
'
' Math.Exp(Math.Log(1.2)) = 1.2000000000000000E+000
' Math.Log(Math.Exp(1.2)) = 1.2000000000000000E+000
'
' Math.Exp(Math.Log(4.9)) = 4.9000000000000012E+000
' Math.Log(Math.Exp(4.9)) = 4.9000000000000004E+000
'
' Math.Exp(Math.Log(9.9)) = 9.9000000000000004E+000
' Math.Log(Math.Exp(9.9)) = 9.9000000000000004E+000
'
' Evaluate these identities with selected values for X and Y:
' (e ^ X) * (e ^ Y) = e ^ (X + Y)
' (e ^ X) ^ Y = e ^ (X * Y)
' X ^ Y = e ^ (Y * ln(X))
'
' Math.Exp(0.1) * Math.Exp(1.2) = 3.6692966676192444E+000
' Math.Exp(0.1 + 1.2) = 3.6692966676192444E+000
' Math.Pow(Math.Exp(0.1), 1.2) = 1.1274968515793757E+000
' Math.Exp(0.1 * 1.2) = 1.1274968515793757E+000
' Math.Pow(0.1, 1.2) = 6.3095734448019331E-002
' Math.Exp(1.2 * Math.Log(0.1)) = 6.3095734448019344E-002
'
' Math.Exp(1.2) * Math.Exp(4.9) = 4.4585777008251705E+002
' Math.Exp(1.2 + 4.9) = 4.4585777008251716E+002
' Math.Pow(Math.Exp(1.2), 4.9) = 3.5780924170885260E+002
' Math.Exp(1.2 * 4.9) = 3.5780924170885277E+002
' Math.Pow(1.2, 4.9) = 2.4433636334442981E+000
' Math.Exp(4.9 * Math.Log(1.2)) = 2.4433636334442981E+000
'
' Math.Exp(4.9) * Math.Exp(9.9) = 2.6764450551890982E+006
' Math.Exp(4.9 + 9.9) = 2.6764450551891015E+006
' Math.Pow(Math.Exp(4.9), 9.9) = 1.1684908531676833E+021
' Math.Exp(4.9 * 9.9) = 1.1684908531676829E+021
' Math.Pow(4.9, 9.9) = 6.8067718210957060E+006
' Math.Exp(9.9 * Math.Log(4.9)) = 6.8067718210956985E+006
Comentarios
e es una constante matemática cuyo valor es aproximadamente 2,71828.
Utilice el Pow método para calcular potencias de otras bases.
Este método llama al tiempo 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.
Se aplica a
Consulte también
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de