Math Clase

  • Referencia

Definición

Espacio de nombres:
System
Ensamblado:
System.Runtime.Extensions.dll
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Proporciona constantes y métodos estáticos para operaciones trigonométricas, logarítmicas 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 Math clase 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 proporción de la circunferencia de un círculo en relación con 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 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 sencilla.
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 corresponde al 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)

Calcula el producto completo de dos números de 32 bits.
BigMul(Int64, Int64, Int64)

Genera el producto completo de dos números de 64 bits.
BigMul(UInt64, UInt64, UInt64)

Genera el producto completo de dos números de 64 bits sin signo.
BitDecrement(Double)

Devuelve el siguiente valor más pequeño menor que x.
BitIncrement(Double)

Devuelve el siguiente valor más grande mayor que x.
Cbrt(Double)

Devuelve la raíz cúbica de un número especificado.
Ceiling(Decimal)

Devuelve el valor integral más pequeño que es mayor o igual que el número decimal especificado.
Ceiling(Double)

Devuelve el valor integral 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 un elemento value fijado al rango inclusivo de min y max.
Clamp(Decimal, Decimal, Decimal)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(Double, Double, Double)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(Int16, Int16, Int16)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(Int32, Int32, Int32)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(Int64, Int64, Int64)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(IntPtr, IntPtr, IntPtr)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(SByte, SByte, SByte)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(Single, Single, Single)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(UInt16, UInt16, UInt16)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(UInt32, UInt32, UInt32)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(UInt64, UInt64, UInt64)

Devuelve un elemento value fijado al rango inclusivo de min y max.
Clamp(UIntPtr, UIntPtr, UIntPtr)

Devuelve un elemento value fijado al rango 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 con signo.
DivRem(Int32, Int32)

Genera el cociente y el resto de dos números de 32 bits con signo.
DivRem(Int32, Int32, Int32)

Calcula el cociente de dos números enteros de 32 bits con signo y devuelve también el resto de la división como 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 números enteros de 64 bits con signo y devuelve también el resto de la división como 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 mayor valor integral menor o igual que el número decimal especificado.
Floor(Double)

Devuelve el mayor valor integral 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 de la división de dos números especificados.
ILogB(Double)

Devuelve el logaritmo de entero en base 2 de un número especificado.
Log(Double)

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

Devuelve el logaritmo de un número especificado en una base determinada.
Log10(Double)

Devuelve el logaritmo en base 10 de un número especificado.
Log2(Double)

Devuelve el logaritmo en base 2 de un número especificado.
Max(Byte, Byte)

Devuelve el mayor de dos enteros de 8 bits sin signo.
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 nativos.
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 nativos sin signo.
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 nativos sin signo.
MinMagnitude(Double, Double)

Devuelve la magnitud menor 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 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 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 utilizando 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 precisión doble al valor entero más cercano y los valores de punto medio al número par más cercano.
Round(Double, Int32)

Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios y los valores de punto medio al número par más cercano.
Round(Double, Int32, MidpointRounding)

Redondea un valor de punto flotante de precisión doble 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 doble precisión.
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 entera de un número decimal especificado.
Truncate(Double)

Calcula la parte entera de un número de punto flotante de precisión doble especificado.

Se aplica a