Math Clase

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.Extensions.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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

Proporciona constantes y métodos estáticos para trigonométricos, logarítmicos y otras funciones matemáticas comunes.

public ref class Math abstract sealed

public ref class Math sealed

public static class Math

public sealed class Math

type Math = class

Public Class Math

Public NotInheritable Class Math

Herencia: Object
Math

Ejemplos

En el ejemplo siguiente se usan varias funciones matemáticas y trigonométricas de la clase Math para calcular los ángulos internos de un trapezoide.

/// <summary>
/// The following class represents simple functionality of the trapezoid.
/// </summary>
using namespace System;

public ref class MathTrapezoidSample
{
private:
   double m_longBase;
   double m_shortBase;
   double m_leftLeg;
   double m_rightLeg;

public:
   MathTrapezoidSample( double longbase, double shortbase, double leftLeg, double rightLeg )
   {
      m_longBase = Math::Abs( longbase );
      m_shortBase = Math::Abs( shortbase );
      m_leftLeg = Math::Abs( leftLeg );
      m_rightLeg = Math::Abs( rightLeg );
   }


private:
   double GetRightSmallBase()
   {
      return (Math::Pow( m_rightLeg, 2.0 ) - Math::Pow( m_leftLeg, 2.0 ) + Math::Pow( m_longBase, 2.0 ) + Math::Pow( m_shortBase, 2.0 ) - 2 * m_shortBase * m_longBase) / (2 * (m_longBase - m_shortBase));
   }


public:
   double GetHeight()
   {
      double x = GetRightSmallBase();
      return Math::Sqrt( Math::Pow( m_rightLeg, 2.0 ) - Math::Pow( x, 2.0 ) );
   }

   double GetSquare()
   {
      return GetHeight() * m_longBase / 2.0;
   }

   double GetLeftBaseRadianAngle()
   {
      double sinX = GetHeight() / m_leftLeg;
      return Math::Round( Math::Asin( sinX ), 2 );
   }

   double GetRightBaseRadianAngle()
   {
      double x = GetRightSmallBase();
      double cosX = (Math::Pow( m_rightLeg, 2.0 ) + Math::Pow( x, 2.0 ) - Math::Pow( GetHeight(), 2.0 )) / (2 * x * m_rightLeg);
      return Math::Round( Math::Acos( cosX ), 2 );
   }

   double GetLeftBaseDegreeAngle()
   {
      double x = GetLeftBaseRadianAngle() * 180 / Math::PI;
      return Math::Round( x, 2 );
   }

   double GetRightBaseDegreeAngle()
   {
      double x = GetRightBaseRadianAngle() * 180 / Math::PI;
      return Math::Round( x, 2 );
   }

};

int main()
{
   MathTrapezoidSample^ trpz = gcnew MathTrapezoidSample( 20.0,10.0,8.0,6.0 );
   Console::WriteLine( "The trapezoid's bases are 20.0 and 10.0, the trapezoid's legs are 8.0 and 6.0" );
   double h = trpz->GetHeight();
   Console::WriteLine( "Trapezoid height is: {0}", h.ToString() );
   double dxR = trpz->GetLeftBaseRadianAngle();
   Console::WriteLine( "Trapezoid left base angle is: {0} Radians", dxR.ToString() );
   double dyR = trpz->GetRightBaseRadianAngle();
   Console::WriteLine( "Trapezoid right base angle is: {0} Radians", dyR.ToString() );
   double dxD = trpz->GetLeftBaseDegreeAngle();
   Console::WriteLine( "Trapezoid left base angle is: {0} Degrees", dxD.ToString() );
   double dyD = trpz->GetRightBaseDegreeAngle();
   Console::WriteLine( "Trapezoid left base angle is: {0} Degrees", dyD.ToString() );
}

/// <summary>
/// The following class represents simple functionality of the trapezoid.
/// </summary>
using System;

namespace MathClassCS
{
    class MathTrapezoidSample
    {
        private double m_longBase;
        private double m_shortBase;
        private double m_leftLeg;
        private double m_rightLeg;

        public MathTrapezoidSample(double longbase, double shortbase, double leftLeg, double rightLeg)
        {
            m_longBase = Math.Abs(longbase);
            m_shortBase = Math.Abs(shortbase);
            m_leftLeg = Math.Abs(leftLeg);
            m_rightLeg = Math.Abs(rightLeg);
        }

        private double GetRightSmallBase()
        {
            return (Math.Pow(m_rightLeg,2.0) - Math.Pow(m_leftLeg,2.0) + Math.Pow(m_longBase,2.0) + Math.Pow(m_shortBase,2.0) - 2* m_shortBase * m_longBase)/ (2*(m_longBase - m_shortBase));
        }

        public double GetHeight()
        {
            double x = GetRightSmallBase();
            return Math.Sqrt(Math.Pow(m_rightLeg,2.0) - Math.Pow(x,2.0));
        }

        public double GetSquare()
        {
            return GetHeight() * m_longBase / 2.0;
        }

        public double GetLeftBaseRadianAngle()
        {
            double sinX = GetHeight()/m_leftLeg;
            return Math.Round(Math.Asin(sinX),2);
        }

        public double GetRightBaseRadianAngle()
        {
            double x = GetRightSmallBase();
            double cosX = (Math.Pow(m_rightLeg,2.0) + Math.Pow(x,2.0) - Math.Pow(GetHeight(),2.0))/(2*x*m_rightLeg);
            return Math.Round(Math.Acos(cosX),2);
        }

        public double GetLeftBaseDegreeAngle()
        {
            double x = GetLeftBaseRadianAngle() * 180/ Math.PI;
            return Math.Round(x,2);
        }

        public double GetRightBaseDegreeAngle()
        {
            double x = GetRightBaseRadianAngle() * 180/ Math.PI;
            return Math.Round(x,2);
        }

        static void Main(string[] args)
        {
            MathTrapezoidSample trpz = new MathTrapezoidSample(20.0, 10.0, 8.0, 6.0);
            Console.WriteLine("The trapezoid's bases are 20.0 and 10.0, the trapezoid's legs are 8.0 and 6.0");
            double h = trpz.GetHeight();
            Console.WriteLine("Trapezoid height is: " + h.ToString());
            double dxR = trpz.GetLeftBaseRadianAngle();
            Console.WriteLine("Trapezoid left base angle is: " + dxR.ToString() + " Radians");
            double dyR = trpz.GetRightBaseRadianAngle();
            Console.WriteLine("Trapezoid right base angle is: " + dyR.ToString() + " Radians");
            double dxD = trpz.GetLeftBaseDegreeAngle();
            Console.WriteLine("Trapezoid left base angle is: " + dxD.ToString() + " Degrees");
            double dyD = trpz.GetRightBaseDegreeAngle();
            Console.WriteLine("Trapezoid left base angle is: " + dyD.ToString() + " Degrees");
        }
    }
}

open System

/// The following class represents simple functionality of the trapezoid.
type MathTrapezoidSample(longbase, shortbase, leftLeg, rightLeg) =
    member _.GetRightSmallBase() =
        (Math.Pow(rightLeg, 2.) - Math.Pow(leftLeg, 2.) + Math.Pow(longbase, 2.) + Math.Pow(shortbase, 2.) - 2. * shortbase * longbase) / (2. * (longbase - shortbase))

    member this.GetHeight() =
        let x = this.GetRightSmallBase()
        Math.Sqrt(Math.Pow(rightLeg, 2.) - Math.Pow(x, 2.))

    member this.GetSquare() =
        this.GetHeight() * longbase / 2.

    member this.GetLeftBaseRadianAngle() =
        let sinX = this.GetHeight() / leftLeg
        Math.Round(Math.Asin sinX,2)

    member this.GetRightBaseRadianAngle() =
        let x = this.GetRightSmallBase()
        let cosX = (Math.Pow(rightLeg, 2.) + Math.Pow(x, 2.) - Math.Pow(this.GetHeight(), 2.))/(2. * x * rightLeg)
        Math.Round(Math.Acos cosX, 2)

    member this.GetLeftBaseDegreeAngle() =
        let x = this.GetLeftBaseRadianAngle() * 180. / Math.PI
        Math.Round(x, 2)

    member this.GetRightBaseDegreeAngle() =
        let x = this.GetRightBaseRadianAngle() * 180. / Math.PI
        Math.Round(x, 2)

let trpz = MathTrapezoidSample(20., 10., 8., 6.)
printfn "The trapezoid's bases are 20.0 and 10.0, the trapezoid's legs are 8.0 and 6.0"
let h = trpz.GetHeight()
printfn $"Trapezoid height is: {h}"
let dxR = trpz.GetLeftBaseRadianAngle()
printfn $"Trapezoid left base angle is: {dxR} Radians"
let dyR = trpz.GetRightBaseRadianAngle()
printfn $"Trapezoid right base angle is: {dyR} Radians"
let dxD = trpz.GetLeftBaseDegreeAngle()
printfn $"Trapezoid left base angle is: {dxD} Degrees"
let dyD = trpz.GetRightBaseDegreeAngle()
printfn $"Trapezoid left base angle is: {dyD} Degrees"

'The following class represents simple functionality of the trapezoid.
Class MathTrapezoidSample

    Private m_longBase As Double
    Private m_shortBase As Double
    Private m_leftLeg As Double
    Private m_rightLeg As Double

    Public Sub New(ByVal longbase As Double, ByVal shortbase As Double, ByVal leftLeg As Double, ByVal rightLeg As Double)
        m_longBase = Math.Abs(longbase)
        m_shortBase = Math.Abs(shortbase)
        m_leftLeg = Math.Abs(leftLeg)
        m_rightLeg = Math.Abs(rightLeg)
    End Sub

    Private Function GetRightSmallBase() As Double
        GetRightSmallBase = (Math.Pow(m_rightLeg, 2) - Math.Pow(m_leftLeg, 2) + Math.Pow(m_longBase, 2) + Math.Pow(m_shortBase, 2) - 2 * m_shortBase * m_longBase) / (2 * (m_longBase - m_shortBase))
    End Function

    Public Function GetHeight() As Double
        Dim x As Double = GetRightSmallBase()
        GetHeight = Math.Sqrt(Math.Pow(m_rightLeg, 2) - Math.Pow(x, 2))
    End Function

    Public Function GetSquare() As Double
        GetSquare = GetHeight() * m_longBase / 2
    End Function

    Public Function GetLeftBaseRadianAngle() As Double
        Dim sinX As Double = GetHeight() / m_leftLeg
        GetLeftBaseRadianAngle = Math.Round(Math.Asin(sinX), 2)
    End Function

    Public Function GetRightBaseRadianAngle() As Double
        Dim x As Double = GetRightSmallBase()
        Dim cosX As Double = (Math.Pow(m_rightLeg, 2) + Math.Pow(x, 2) - Math.Pow(GetHeight(), 2)) / (2 * x * m_rightLeg)
        GetRightBaseRadianAngle = Math.Round(Math.Acos(cosX), 2)
    End Function

    Public Function GetLeftBaseDegreeAngle() As Double
        Dim x As Double = GetLeftBaseRadianAngle() * 180 / Math.PI
        GetLeftBaseDegreeAngle = Math.Round(x, 2)
    End Function

    Public Function GetRightBaseDegreeAngle() As Double
        Dim x As Double = GetRightBaseRadianAngle() * 180 / Math.PI
        GetRightBaseDegreeAngle = Math.Round(x, 2)
    End Function

    Public Shared Sub Main()
        Dim trpz As MathTrapezoidSample = New MathTrapezoidSample(20, 10, 8, 6)
        Console.WriteLine("The trapezoid's bases are 20.0 and 10.0, the trapezoid's legs are 8.0 and 6.0")
        Dim h As Double = trpz.GetHeight()
        Console.WriteLine("Trapezoid height is: " + h.ToString())
        Dim dxR As Double = trpz.GetLeftBaseRadianAngle()
        Console.WriteLine("Trapezoid left base angle is: " + dxR.ToString() + " Radians")
        Dim dyR As Double = trpz.GetRightBaseRadianAngle()
        Console.WriteLine("Trapezoid right base angle is: " + dyR.ToString() + " Radians")
        Dim dxD As Double = trpz.GetLeftBaseDegreeAngle()
        Console.WriteLine("Trapezoid left base angle is: " + dxD.ToString() + " Degrees")
        Dim dyD As Double = trpz.GetRightBaseDegreeAngle()
        Console.WriteLine("Trapezoid left base angle is: " + dyD.ToString() + " Degrees")
    End Sub
End Class

Campos

E	Representa la base logarítmica natural, especificada por la constante, `e`.
PI	Representa la relación de la circunferencia de un círculo a su diámetro, especificado por la constante, π.
Tau	Representa el número de radianes en un turno, especificado por la constante, τ.

Métodos

Abs(Decimal)	Devuelve el valor absoluto de un número de Decimal.
Abs(Double)	Devuelve el valor absoluto de un número de punto flotante de precisión doble.
Abs(Int16)	Devuelve el valor absoluto de un entero de 16 bits con signo.
Abs(Int32)	Devuelve el valor absoluto de un entero de 32 bits con signo.
Abs(Int64)	Devuelve el valor absoluto de un entero de 64 bits con signo.
Abs(IntPtr)	Devuelve el valor absoluto de un entero con signo nativo.
Abs(SByte)	Devuelve el valor absoluto de un entero de 8 bits con signo.
Abs(Single)	Devuelve el valor absoluto de un número de punto flotante de precisión única.
Acos(Double)	Devuelve el ángulo cuyo coseno es el número especificado.
Acosh(Double)	Devuelve el ángulo cuyo coseno hiperbólico es el número especificado.
Asin(Double)	Devuelve el ángulo cuyo seno es el número especificado.
Asinh(Double)	Devuelve el ángulo cuyo seno hiperbólico es el número especificado.
Atan(Double)	Devuelve el ángulo cuya tangente es el número especificado.
Atan2(Double, Double)	Devuelve el ángulo cuya tangente es el cociente de dos números especificados.
Atanh(Double)	Devuelve el ángulo cuya tangente hiperbólica es el número especificado.
BigMul(Int32, Int32)	Genera el producto completo de dos números de 32 bits.
BigMul(Int64, Int64)	Genera el producto completo de dos números de 64 bits.
BigMul(Int64, Int64, Int64)	Genera el producto completo de dos números de 64 bits.
BigMul(UInt32, UInt32)	Genera el producto completo de dos números de 32 bits sin signo.
BigMul(UInt64, UInt64)	Genera el producto completo de dos números de 64 bits sin signo.
BigMul(UInt64, UInt64, UInt64)	Genera el producto completo de dos números de 64 bits sin signo.
BitDecrement(Double)	Devuelve el valor más grande que compara menos que un valor especificado.
BitIncrement(Double)	Devuelve el valor más pequeño que compara mayor que un valor especificado.
Cbrt(Double)	Devuelve la raíz del cubo de un número especificado.
Ceiling(Decimal)	Devuelve el valor entero más pequeño que es mayor o igual que el número decimal especificado.
Ceiling(Double)	Devuelve el valor entero más pequeño que es mayor o igual que el número de punto flotante de precisión doble especificado.
Clamp(Byte, Byte, Byte)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(Decimal, Decimal, Decimal)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(Double, Double, Double)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(Int16, Int16, Int16)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(Int32, Int32, Int32)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(Int64, Int64, Int64)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(IntPtr, IntPtr, IntPtr)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(SByte, SByte, SByte)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(Single, Single, Single)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(UInt16, UInt16, UInt16)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(UInt32, UInt32, UInt32)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(UInt64, UInt64, UInt64)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
Clamp(UIntPtr, UIntPtr, UIntPtr)	Devuelve `value` abrazado al intervalo inclusivo de `min` y `max`.
CopySign(Double, Double)	Devuelve un valor con la magnitud de `x` y el signo de `y`.
Cos(Double)	Devuelve el coseno del ángulo especificado.
Cosh(Double)	Devuelve el coseno hiperbólico del ángulo especificado.
DivRem(Byte, Byte)	Genera el cociente y el resto de dos números de 8 bits sin signo.
DivRem(Int16, Int16)	Genera el cociente y el resto de dos números de 16 bits firmados.
DivRem(Int32, Int32)	Genera el cociente y el resto de dos números de 32 bits firmados.
DivRem(Int32, Int32, Int32)	Calcula el cociente de dos enteros con signo de 32 bits y también devuelve el resto en un parámetro de salida.
DivRem(Int64, Int64)	Genera el cociente y el resto de dos números de 64 bits firmados.
DivRem(Int64, Int64, Int64)	Calcula el cociente de dos enteros con signo de 64 bits y también devuelve el resto en un parámetro de salida.
DivRem(IntPtr, IntPtr)	Genera el cociente y el resto de dos números de tamaño nativo firmados.
DivRem(SByte, SByte)	Genera el cociente y el resto de dos números de 8 bits con signo.
DivRem(UInt16, UInt16)	Genera el cociente y el resto de dos números de 16 bits sin signo.
DivRem(UInt32, UInt32)	Genera el cociente y el resto de dos números de 32 bits sin signo.
DivRem(UInt64, UInt64)	Genera el cociente y el resto de dos números de 64 bits sin signo.
DivRem(UIntPtr, UIntPtr)	Genera el cociente y el resto de dos números de tamaño nativo sin signo.
Exp(Double)	Devuelve `e` elevado a la potencia especificada.
Floor(Decimal)	Devuelve el valor entero más grande menor o igual que el número decimal especificado.
Floor(Double)	Devuelve el valor entero más grande menor o igual que el número de punto flotante de precisión doble especificado.
FusedMultiplyAdd(Double, Double, Double)	Devuelve (x * y) + z, redondeado como una operación ternaria.
IEEERemainder(Double, Double)	Devuelve el resto resultante de la división de un número especificado por otro número especificado.
ILogB(Double)	Devuelve el logaritmo entero base 2 de un número especificado.
Log(Double)	Devuelve el logaritmo natural (base `e`) de un número especificado.
Log(Double, Double)	Devuelve el logaritmo de un número especificado en una base especificada.
Log10(Double)	Devuelve el logaritmo base 10 de un número especificado.
Log2(Double)	Devuelve el logaritmo base 2 de un número especificado.
Max(Byte, Byte)	Devuelve el mayor de dos enteros sin signo de 8 bits.
Max(Decimal, Decimal)	Devuelve el mayor de dos números decimales.
Max(Double, Double)	Devuelve el mayor de dos números de punto flotante de precisión doble.
Max(Int16, Int16)	Devuelve el mayor de dos enteros de 16 bits con signo.
Max(Int32, Int32)	Devuelve el mayor de dos enteros de 32 bits con signo.
Max(Int64, Int64)	Devuelve el mayor de dos enteros de 64 bits con signo.
Max(IntPtr, IntPtr)	Devuelve el mayor de dos enteros con signo nativo.
Max(SByte, SByte)	Devuelve el mayor de dos enteros de 8 bits con signo.
Max(Single, Single)	Devuelve el mayor de dos números de punto flotante de precisión sencilla.
Max(UInt16, UInt16)	Devuelve el mayor de dos enteros de 16 bits sin signo.
Max(UInt32, UInt32)	Devuelve el mayor de dos enteros de 32 bits sin signo.
Max(UInt64, UInt64)	Devuelve el mayor de dos enteros de 64 bits sin signo.
Max(UIntPtr, UIntPtr)	Devuelve el mayor de dos enteros sin signo nativos.
MaxMagnitude(Double, Double)	Devuelve la magnitud mayor de dos números de punto flotante de precisión doble.
Min(Byte, Byte)	Devuelve el menor de dos enteros de 8 bits sin signo.
Min(Decimal, Decimal)	Devuelve el menor de dos números decimales.
Min(Double, Double)	Devuelve el menor de dos números de punto flotante de precisión doble.
Min(Int16, Int16)	Devuelve el menor de dos enteros de 16 bits con signo.
Min(Int32, Int32)	Devuelve el menor de dos enteros de 32 bits con signo.
Min(Int64, Int64)	Devuelve el menor de dos enteros de 64 bits con signo.
Min(IntPtr, IntPtr)	Devuelve el menor de dos enteros con signo nativo.
Min(SByte, SByte)	Devuelve el menor de dos enteros de 8 bits con signo.
Min(Single, Single)	Devuelve el menor de dos números de punto flotante de precisión sencilla.
Min(UInt16, UInt16)	Devuelve el menor de dos enteros de 16 bits sin signo.
Min(UInt32, UInt32)	Devuelve el menor de dos enteros de 32 bits sin signo.
Min(UInt64, UInt64)	Devuelve el menor de dos enteros de 64 bits sin signo.
Min(UIntPtr, UIntPtr)	Devuelve el menor de dos enteros sin signo nativos.
MinMagnitude(Double, Double)	Devuelve la magnitud más pequeña de dos números de punto flotante de precisión doble.
Pow(Double, Double)	Devuelve un número especificado elevado a la potencia especificada.
ReciprocalEstimate(Double)	Devuelve una estimación de la recíproca de un número especificado.
ReciprocalSqrtEstimate(Double)	Devuelve una estimación de la raíz cuadrada recíproca de un número especificado.
Round(Decimal)	Redondea un valor decimal al valor entero más cercano y redondea los valores de punto medio al número par más cercano.
Round(Decimal, Int32)	Redondea un valor decimal a un número especificado de dígitos fraccionarios y redondea los valores de punto medio al número par más cercano.
Round(Decimal, Int32, MidpointRounding)	Redondea un valor decimal a un número especificado de dígitos fraccionarios mediante la convención de redondeo especificada.
Round(Decimal, MidpointRounding)	Redondea un valor decimal un entero mediante la convención de redondeo especificada.
Round(Double)	Redondea un valor de punto flotante de doble precisión al valor entero más cercano y redondea los valores de punto medio al número par más cercano.
Round(Double, Int32)	Redondea un valor de punto flotante de doble precisión a un número especificado de dígitos fraccionarios y redondea los valores de punto medio al número par más cercano.
Round(Double, Int32, MidpointRounding)	Redondea un valor de punto flotante de doble precisión a un número especificado de dígitos fraccionarios mediante la convención de redondeo especificada.
Round(Double, MidpointRounding)	Redondea un valor de punto flotante de doble precisión a un entero mediante la convención de redondeo especificada.
ScaleB(Double, Int32)	Devuelve x * 2^n calculado de forma eficaz.
Sign(Decimal)	Devuelve un entero que indica el signo de un número decimal.
Sign(Double)	Devuelve un entero que indica el signo de un número de punto flotante de precisión doble.
Sign(Int16)	Devuelve un entero que indica el signo de un entero de 16 bits con signo.
Sign(Int32)	Devuelve un entero que indica el signo de un entero de 32 bits con signo.
Sign(Int64)	Devuelve un entero que indica el signo de un entero de 64 bits con signo.
Sign(IntPtr)	Devuelve un entero que indica el signo de un entero con signo de tamaño nativo con signo.
Sign(SByte)	Devuelve un entero que indica el signo de un entero de 8 bits con signo.
Sign(Single)	Devuelve un entero que indica el signo de un número de punto flotante de precisión sencilla.
Sin(Double)	Devuelve el seno del ángulo especificado.
SinCos(Double)	Devuelve el seno y el coseno del ángulo especificado.
Sinh(Double)	Devuelve el seno hiperbólico del ángulo especificado.
Sqrt(Double)	Devuelve la raíz cuadrada de un número especificado.
Tan(Double)	Devuelve la tangente del ángulo especificado.
Tanh(Double)	Devuelve la tangente hiperbólica del ángulo especificado.
Truncate(Decimal)	Calcula la parte integral de un número decimal especificado.
Truncate(Double)	Calcula la parte integral de un número de punto flotante de precisión doble especificado.

Se aplica a

Compartir a través de