Math Classe

Definição

Espaço de Nomes:
System
Assemblagens:
mscorlib.dll, System.Runtime.Extensions.dll
Assemblagens:
netstandard.dll, System.Runtime.dll
Assemblagem:
System.Runtime.Extensions.dll
Assemblagem:
mscorlib.dll
Assemblagem:
netstandard.dll
Origem:
Math.cs
Origem:
Math.cs
Origem:
Math.cs
Origem:
Math.cs
Origem:
Math.cs

Fornece constantes e métodos estáticos para funções matemáticas trigonométricas, logarítmicas e outras 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 seguinte utiliza várias funções matemáticas e trigonométricas da Math classe para calcular os ângulos interiores de um trapézio.

/// <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 right 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 right 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 right base angle is: " + dyD.ToString() + " Degrees")
    End Sub
End Class

Campos

Name Description
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 o seu diâmetro, especificada pela constante, π.
Tau

Representa o número de radianos numa volta, especificado pela constante, τ.

Métodos

Name Description
Abs(Decimal)

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

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

Devolve o valor absoluto de um inteiro assinado de 16 bits.
Abs(Int32)

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

Devolve o valor absoluto de um inteiro assinado de 64 bits.
Abs(IntPtr)

Devolve o valor absoluto de um inteiro nativo com signo.
Abs(SByte)

Devolve o valor absoluto de um inteiro assinado de 8 bits.
Abs(Single)

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

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

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

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

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

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

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

Devolve 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)

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

Produz o produto completo de dois números de 64 bits.
BigMul(UInt32, UInt32)

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

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

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

Devolve o maior valor que se compara a menos do que um valor especificado.
BitIncrement(Double)

Devolve o menor valor que se compara a um valor especificado.
Cbrt(Double)

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

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

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

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(Decimal, Decimal, Decimal)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(Double, Double, Double)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(Int16, Int16, Int16)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(Int32, Int32, Int32)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(Int64, Int64, Int64)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(IntPtr, IntPtr, IntPtr)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(SByte, SByte, SByte)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(Single, Single, Single)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(UInt16, UInt16, UInt16)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(UInt32, UInt32, UInt32)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(UInt64, UInt64, UInt64)

Retornos value fixos ao intervalo inclusivo de min e max.
Clamp(UIntPtr, UIntPtr, UIntPtr)

Retornos value fixos ao intervalo inclusivo de min e max.
CopySign(Double, Double)

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

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

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

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

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

Calcula o quociente de dois inteiros assinados de 32 bits e também devolve o restante num parâmetro de saída.
DivRem(Int32, Int32)

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

Calcula o quociente de dois inteiros assinados de 64 bits e também devolve o restante num parâmetro de saída.
DivRem(Int64, Int64)

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

Produz o quociente e o restante de dois números nativos 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 não sinalizados de 16 bits.
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 não signados de 64 bits.
DivRem(UIntPtr, UIntPtr)

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

Retornos e aumentados para a potência especificada.
Floor(Decimal)

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

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

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

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

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

Devolve o logaritmo de um número especificado numa base especificada.
Log(Double)

Devolve o logaritmo natural (base e) de um número especificado.
Log10(Double)

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

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

Devolve o maior dos dois inteiros sem sinal de 8 bits.
Max(Decimal, Decimal)

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

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

Devolve o maior dos dois inteiros assinados de 16 bits.
Max(Int32, Int32)

Devolve o maior dos dois inteiros assinados de 32 bits.
Max(Int64, Int64)

Devolve o maior dos dois inteiros assinados de 64 bits.
Max(IntPtr, IntPtr)

Devolve o maior dos dois inteiros nativos assinados.
Max(SByte, SByte)

Devolve o maior dos dois inteiros assinados de 8 bits.
Max(Single, Single)

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

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

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

Devolve o maior dos dois inteiros sem sinal de 64 bits.
Max(UIntPtr, UIntPtr)

Devolve o maior dos dois inteiros nativos sem sinal.
MaxMagnitude(Double, Double)

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

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

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

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

Devolve o menor dos dois inteiros assinados de 16 bits.
Min(Int32, Int32)

Devolve o menor dos dois inteiros assinados de 32 bits.
Min(Int64, Int64)

Devolve o menor dos dois inteiros assinados de 64 bits.
Min(IntPtr, IntPtr)

Devolve o menor dos dois inteiros nativos assinados.
Min(SByte, SByte)

Devolve o menor dos dois inteiros assinados de 8 bits.
Min(Single, Single)

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

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

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

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

Devolve o menor dos dois inteiros nativos sem sinal.
MinMagnitude(Double, Double)

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

Devolve um número especificado elevado para a potência especificada.
ReciprocalEstimate(Double)

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

Devolve uma estimativa da raiz quadrada recíproca de um número especificado.
Round(Decimal, Int32, MidpointRounding)

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

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

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

Arredonda um valor decimal para o valor integral mais próximo e arredonda valores do ponto médio para o número par mais próximo.
Round(Double, Int32, MidpointRounding)

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

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

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

Arredonda um valor de ponto flutuante de dupla precisão ao valor integral mais próximo, e arredonda valores do ponto médio ao número par mais próximo.
ScaleB(Double, Int32)

Retorna x * 2^n calculado eficientemente.
Sign(Decimal)

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

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

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

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

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

Devolve um inteiro que indica o sinal de um inteiro com sinal de tamanho nativo.
Sign(SByte)

Devolve um inteiro que indica o sinal de um inteiro assinado de 8 bits.
Sign(Single)

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

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

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

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

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

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

Devolve 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 dupla precisão especificado.

Aplica-se a