Math Classe

  • Referência

Definição

Namespace:
System
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll
Assembly:
mscorlib.dll

Fornece constantes e métodos estáticos para trigonométricas, logarítmicas e outras funções matemáticas comuns.

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
Herança
Object
Math

Exemplos

O exemplo a seguir usa várias funções matemáticas e trigonométricas da Math classe para calcular os ângulos internos de um trapézio.

/// <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");
        }
    }
}

'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 a base logarítmica natural, especificada pela constante e.
PI

Representa a razão entre a circunferência de um círculo e seu diâmetro, especificada pela constante π.
Tau

Representa o número de radianos em um turno, especificado pela constante, τ.

Métodos

Abs(Decimal)

Retorna o valor absoluto de um número Decimal.
Abs(Double)

Retorna o valor absoluto de um número de ponto flutuante de precisão dupla.
Abs(Int16)

Retorna o valor absoluto de um inteiro com sinal de 16 bits.
Abs(Int32)

Retorna o valor absoluto de um inteiro com sinal de 32 bits.
Abs(Int64)

Retorna o valor absoluto de um inteiro com sinal de 64 bits.
Abs(IntPtr)

Retorna o valor absoluto de um inteiro assinado nativo.
Abs(SByte)

Retorna o valor absoluto de um inteiro com sinal de 8 bits.
Abs(Single)

Retorna o valor absoluto de um número de ponto flutuante de precisão simples.
Acos(Double)

Retorna o ângulo cujo cosseno é o número especificado.
Acosh(Double)

Retorna o ângulo cujo cosseno hiperbólico é o número especificado.
Asin(Double)

Retorna o ângulo cujo seno é o número especificado.
Asinh(Double)

Retorna o ângulo cujo seno hiperbólico é o número especificado.
Atan(Double)

Retorna o ângulo cuja tangente é o número especificado.
Atan2(Double, Double)

Retorna o ângulo cuja tangente é o quociente de dois números especificados.
Atanh(Double)

Retorna o ângulo cuja tangente hiperbólica é o número especificado.
BigMul(Int32, Int32)

Produz o produto completo de dois números de 32 bits.
BigMul(Int64, Int64, Int64)

Gera o produto completo de dois números de 64 bits.
BigMul(UInt64, UInt64, UInt64)

Gera o produto completo de dois números de 64 bits sem sinal.
BitDecrement(Double)

Retorna o próximo valor menor que é comparado como menor que x.
BitIncrement(Double)

Retorna o próximo valor maior que é comparado como maior que x.
Cbrt(Double)

Retorna a raiz cúbica de um número especificado.
Ceiling(Decimal)

Retorna o menor valor integral maior ou igual ao número decimal especificado.
Ceiling(Double)

Retorna o menor valor integral maior ou igual ao número de ponto flutuante de precisão dupla especificado.
Clamp(Byte, Byte, Byte)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(Decimal, Decimal, Decimal)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(Double, Double, Double)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(Int16, Int16, Int16)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(Int32, Int32, Int32)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(Int64, Int64, Int64)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(IntPtr, IntPtr, IntPtr)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(SByte, SByte, SByte)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(Single, Single, Single)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(UInt16, UInt16, UInt16)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(UInt32, UInt32, UInt32)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(UInt64, UInt64, UInt64)

Retorna value fixado no intervalo inclusivo de min e max.
Clamp(UIntPtr, UIntPtr, UIntPtr)

Retorna value fixado no intervalo inclusivo de min e max.
CopySign(Double, Double)

Retorna um valor com magnitude de x e o sinal de y.
Cos(Double)

Retorna o cosseno do ângulo especificado.
Cosh(Double)

Retorna o cosseno hiperbólico do ângulo especificado.
DivRem(Byte, Byte)

Produz o quociente e o restante de dois números de 8 bits não assinados.
DivRem(Int16, Int16)

Produz o quociente e o restante de dois números de 16 bits assinados.
DivRem(Int32, Int32)

Produz o quociente e o restante de dois números de 32 bits assinados.
DivRem(Int32, Int32, Int32)

Calcula o quociente de dois inteiros de 32 bits com sinal e também retorna o resto em um parâmetro de saída.
DivRem(Int64, Int64)

Produz o quociente e o restante de dois números de 64 bits assinados.
DivRem(Int64, Int64, Int64)

Calcula o quociente de dois inteiros com sinal de 64 bits e também retorna o restante em um parâmetro de saída.
DivRem(IntPtr, IntPtr)

Produz o quociente e o restante de dois números de tamanho nativo assinados.
DivRem(SByte, SByte)

Produz o quociente e o restante de dois números de 8 bits assinados.
DivRem(UInt16, UInt16)

Produz o quociente e o restante de dois números de 16 bits não assinados.
DivRem(UInt32, UInt32)

Produz o quociente e o restante de dois números de 32 bits sem sinal.
DivRem(UInt64, UInt64)

Produz o quociente e o restante de dois números de 64 bits sem sinal.
DivRem(UIntPtr, UIntPtr)

Produz o quociente e o restante de dois números de tamanho nativo sem sinal.
Exp(Double)

Retorna e elevado à potência especificada.
Floor(Decimal)

Retorna o maior valor integral menor ou igual ao número decimal especificado.
Floor(Double)

Retorna o maior valor integral menor ou igual ao número de ponto flutuante de precisão dupla especificado.
FusedMultiplyAdd(Double, Double, Double)

Retorna (x * y) + z, arredondado como uma operação ternária.
IEEERemainder(Double, Double)

Retorna o resultado restante da divisão de um número especificado por outro número especificado.
ILogB(Double)

Retorna o logaritmo inteiro de base 2 de um número especificado.
Log(Double)

Retorna o logaritmo natural (de base e) de um número especificado.
Log(Double, Double)

Retorna o logaritmo de um número especificado em uma base especificada.
Log10(Double)

Retorna o logaritmo de base 10 de um número especificado.
Log2(Double)

Retorna o logaritmo de base 2 de um número especificado.
Max(Byte, Byte)

Retorna o maior entre dois inteiros sem sinal de 8 bits.
Max(Decimal, Decimal)

Retorna o maior dos dois números decimais.
Max(Double, Double)

Retorna o maior dos dois números de ponto flutuante de precisão dupla.
Max(Int16, Int16)

Retorna o maior dos dois inteiros com sinal de 16 bits.
Max(Int32, Int32)

Retorna o maior dos dois inteiros com sinal de 32 bits.
Max(Int64, Int64)

Retorna o maior dos dois inteiros com sinal de 64 bits.
Max(IntPtr, IntPtr)

Retorna o maior de dois inteiros com sinal nativo.
Max(SByte, SByte)

Retorna o maior dos dois inteiros com sinal de 8 bits.
Max(Single, Single)

Retorna o maior dos dois números de ponto flutuante de precisão simples.
Max(UInt16, UInt16)

Retorna o maior de dois inteiros sem sinal de 16 bits.
Max(UInt32, UInt32)

Retorna o maior de dois inteiros sem sinal de 32 bits.
Max(UInt64, UInt64)

Retorna o maior entre dois inteiros sem sinal de 64 bits.
Max(UIntPtr, UIntPtr)

Retorna o maior de dois inteiros nativos não assinados.
MaxMagnitude(Double, Double)

Retorna a maior magnitude de dois números de ponto flutuante de precisão dupla.
Min(Byte, Byte)

Retorna o menor dos dois inteiros sem sinal de 8 bits.
Min(Decimal, Decimal)

Retorna o menor dos dois números decimais.
Min(Double, Double)

Retorna o menor dos dois números de ponto flutuante de precisão dupla.
Min(Int16, Int16)

Retorna o menor de dois inteiros com sinal de 16 bits.
Min(Int32, Int32)

Retorna o menor de dois inteiros com sinal de 32 bits.
Min(Int64, Int64)

Retorna o menor de dois inteiros com sinal de 64 bits.
Min(IntPtr, IntPtr)

Retorna o menor de dois inteiros com sinal nativo.
Min(SByte, SByte)

Retorna o menor de dois inteiros com sinal de 8 bits.
Min(Single, Single)

Retorna o menor de dois números de ponto flutuante de precisão simples.
Min(UInt16, UInt16)

Retorna o menor dos dois inteiros sem sinal de 16 bits.
Min(UInt32, UInt32)

Retorna o menor de dois inteiros sem sinal de 32 bits.
Min(UInt64, UInt64)

Retorna o menor de dois inteiros sem sinal de 64 bits.
Min(UIntPtr, UIntPtr)

Retorna o menor de dois inteiros nativos não assinados.
MinMagnitude(Double, Double)

Retorna a menor magnitude de dois números de ponto flutuante de precisão dupla.
Pow(Double, Double)

Retorna um número especificado elevado à potência especificada.
ReciprocalEstimate(Double)

Retorna uma estimativa do recíproco de um número especificado.
ReciprocalSqrtEstimate(Double)

Retorna uma estimativa da raiz quadrada recíproca de um número especificado.
Round(Decimal)

Arredonda um valor decimal para o valor inteiro mais próximo e arredonda os valores de ponto médio para o número par mais próximo.
Round(Decimal, Int32)

Arredonda um valor decimal para o número especificado de dígitos fracionários e arredonda os valores de ponto médio para o número par mais próximo.
Round(Decimal, Int32, MidpointRounding)

Arredonda um valor decimal para um número especificado de dígitos fracionados usando a convenção de arredondamento especificada.
Round(Decimal, MidpointRounding)

Arredonda um valor decimal de um inteiro usando a convenção de arredondamento especificada.
Round(Double)

Arredonda um valor de ponto flutuante de precisão dupla para o valor inteiro mais próximo e arredonda os valores de ponto médio para o número par mais próximo.
Round(Double, Int32)

Arredonda um valor de ponto flutuante de precisão dupla para o número especificado de dígitos fracionários e arredonda os valores de ponto médio para o número par mais próximo.
Round(Double, Int32, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para um número especificado de dígitos fracionários usando a Convenção de arredondamento especificada.
Round(Double, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para um inteiro usando a convenção de arredondamento especificada.
ScaleB(Double, Int32)

Retorna x * 2^n computado com eficiência.
Sign(Decimal)

Retorna um inteiro que indica o sinal de um número decimal.
Sign(Double)

Retorna um inteiro que indica o sinal de um número de ponto flutuante de precisão dupla.
Sign(Int16)

Retorna um inteiro que indica o sinal de um inteiro com sinal de 16 bits.
Sign(Int32)

Retorna um inteiro que indica o sinal de um inteiro com sinal de 32 bits.
Sign(Int64)

Retorna um inteiro que indica o sinal de um inteiro com sinal de 64 bits.
Sign(IntPtr)

Retorna um inteiro que indica o sinal de um inteiro assinado de tamanho nativo.
Sign(SByte)

Retorna um inteiro que indica o sinal de um inteiro com sinal de 8 bits.
Sign(Single)

Retorna um inteiro que indica o sinal de um número de ponto flutuante de precisão simples.
Sin(Double)

Retorna o seno do ângulo especificado.
SinCos(Double)

Retorna o seno e o cosseno do ângulo especificado.
Sinh(Double)

Retorna o seno hiperbólico do ângulo especificado.
Sqrt(Double)

Retorna a raiz quadrada de um número especificado.
Tan(Double)

Retorna a tangente do ângulo especificado.
Tanh(Double)

Retorna a tangente hiperbólica do ângulo especificado.
Truncate(Decimal)

Calcula a parte integral de um número decimal especificado.
Truncate(Double)

Calcula a parte integral de um número de ponto flutuante de precisão dupla especificado.

Aplica-se a