Math Classe

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll
Assembly:
mscorlib.dll

Vengono forniti costanti e metodi statici per eseguire funzioni trigonometriche, logaritmiche e normali funzioni matematiche.

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
Ereditarietà
Object
Math

Esempio

L'esempio seguente usa diverse funzioni matematiche e trigonometriche della classe per calcolare gli Math angoli interni di un tracutoide.

/// <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

Campi

E

Rappresenta la base logaritmica naturale, specificata dalla costante, e.
PI

Rappresenta il rapporto tra la circonferenza del cerchio e il relativo diametro, specificato dalla costante π.
Tau

Rappresenta il numero di radianti in un angolo giro, specificati dalla costante τ.

Metodi

Abs(Decimal)

Restituisce il valore assoluto di un numero Decimal.
Abs(Double)

Restituisce il valore assoluto di un numero a virgola mobile e precisione doppia.
Abs(Int16)

Restituisce il valore assoluto di un intero con segno a 16 bit.
Abs(Int32)

Restituisce il valore assoluto di un intero con segno a 32 bit.
Abs(Int64)

Restituisce il valore assoluto di un intero con segno a 64 bit.
Abs(IntPtr)

Restituisce il valore assoluto di un intero con segno nativo.
Abs(SByte)

Restituisce il valore assoluto di un intero con segno a 8 bit.
Abs(Single)

Restituisce il valore assoluto di un numero a virgola mobile e precisione singola.
Acos(Double)

Restituisce l'angolo il cui coseno è il numero specificato.
Acosh(Double)

Restituisce l'angolo il cui coseno iperbolico è il numero specificato.
Asin(Double)

Restituisce l'angolo il cui seno è il numero specificato.
Asinh(Double)

Restituisce l'angolo il cui seno iperbolico è il numero specificato.
Atan(Double)

Restituisce l'angolo la cui tangente è il numero specificato.
Atan2(Double, Double)

Restituisce l'angolo la cui tangente è il quoziente di due numeri specificati.
Atanh(Double)

Restituisce l'angolo la cui tangente iperbolica è il numero specificato.
BigMul(Int32, Int32)

Restituisce il prodotto completo di due numeri a 32 bit.
BigMul(Int64, Int64, Int64)

Restituisce il prodotto completo di due numeri a 64 bit.
BigMul(UInt64, UInt64, UInt64)

Restituisce il prodotto completo di due numeri a 64 bit senza segno.
BitDecrement(Double)

Restituisce il successivo valore più piccolo che risulta minore di x.
BitIncrement(Double)

Restituisce il successivo valore più grande che risulta maggiore di x.
Cbrt(Double)

Restituisce la radice cubica di un numero specificato.
Ceiling(Decimal)

Restituisce il valore integrale minimo maggiore o uguale al numero decimale specificato.
Ceiling(Double)

Restituisce il valore integrale minimo maggiore del o uguale al numero a virgola mobile e con precisione doppia specificato.
Clamp(Byte, Byte, Byte)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(Decimal, Decimal, Decimal)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(Double, Double, Double)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(Int16, Int16, Int16)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(Int32, Int32, Int32)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(Int64, Int64, Int64)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(IntPtr, IntPtr, IntPtr)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(SByte, SByte, SByte)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(Single, Single, Single)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(UInt16, UInt16, UInt16)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(UInt32, UInt32, UInt32)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(UInt64, UInt64, UInt64)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
Clamp(UIntPtr, UIntPtr, UIntPtr)

Restituisce il valore value fissato all'intervallo inclusivo di min e max.
CopySign(Double, Double)

Restituisce un valore con grandezza pari a x e segno y.
Cos(Double)

Restituisce il coseno dell'angolo specificato.
Cosh(Double)

Restituisce il coseno iperbolico dell'angolo specificato.
DivRem(Byte, Byte)

Produce il quoziente e il resto di due numeri a 8 bit senza segno.
DivRem(Int16, Int16)

Produce il quoziente e il resto di due numeri a 16 bit con segno.
DivRem(Int32, Int32)

Produce il quoziente e il resto di due numeri a 32 bit con segno.
DivRem(Int32, Int32, Int32)

Calcola il quoziente di due interi con segno a 32 bit e restituisce il resto come parametro di output.
DivRem(Int64, Int64)

Produce il quoziente e il resto di due numeri a 64 bit con segno.
DivRem(Int64, Int64, Int64)

Calcola il quoziente di due interi con segno a 64 bit e restituisce il resto come parametro di output.
DivRem(IntPtr, IntPtr)

Produce il quoziente e il resto di due numeri di dimensioni native firmati.
DivRem(SByte, SByte)

Produce il quoziente e il resto di due numeri a 8 bit con segno.
DivRem(UInt16, UInt16)

Produce il quoziente e il resto di due numeri a 16 bit senza segno.
DivRem(UInt32, UInt32)

Produce il quoziente e il resto di due numeri a 32 bit senza segno.
DivRem(UInt64, UInt64)

Produce il quoziente e il resto di due numeri a 64 bit senza segno.
DivRem(UIntPtr, UIntPtr)

Produce il quoziente e il resto di due numeri di dimensioni native senza segno.
Exp(Double)

Restituisce e elevato alla potenza specificata.
Floor(Decimal)

Restituisce il valore integrale massimo minore o uguale al numero decimale specificato.
Floor(Double)

Restituisce il valore integrale massimo minore o uguale al numero a virgola mobile a precisione doppia specificato.
FusedMultiplyAdd(Double, Double, Double)

Restituisce (x * y) + z, arrotondato come unica operazione ternaria.
IEEERemainder(Double, Double)

Restituisce il resto della divisione tra il numero specificato e un altro numero specificato.
ILogB(Double)

Restituisce la parte intera del logaritmo in base 2 del numero specificato.
Log(Double)

Restituisce il logaritmo naturale (in base e) di un numero specificato.
Log(Double, Double)

Restituisce il logaritmo del numero specificato in una base specificata.
Log10(Double)

Restituisce il logaritmo in base 10 del numero specificato.
Log2(Double)

Restituisce il logaritmo in base 2 di un numero specificato.
Max(Byte, Byte)

Restituisce il più elevato tra due interi senza segno a 8 bit.
Max(Decimal, Decimal)

Restituisce il più elevato tra due numeri decimali.
Max(Double, Double)

Restituisce il più elevato tra due numeri a virgola mobile e precisione doppia.
Max(Int16, Int16)

Restituisce il più elevato tra due interi con segno a 16 bit.
Max(Int32, Int32)

Restituisce il più elevato tra due interi con segno a 32 bit.
Max(Int64, Int64)

Restituisce il più elevato tra due interi con segno a 64 bit.
Max(IntPtr, IntPtr)

Restituisce il valore più grande di due interi con segno nativi.
Max(SByte, SByte)

Restituisce il più elevato tra due interi con segno a 8 bit.
Max(Single, Single)

Restituisce il più elevato tra due numeri a virgola mobile e precisione singola.
Max(UInt16, UInt16)

Restituisce il più elevato tra due interi senza segno a 16 bit.
Max(UInt32, UInt32)

Restituisce il più elevato tra due interi senza segno a 32 bit.
Max(UInt64, UInt64)

Restituisce il più elevato tra due interi senza segno a 64 bit.
Max(UIntPtr, UIntPtr)

Restituisce il valore più grande di due interi senza segno nativi.
MaxMagnitude(Double, Double)

Restituisce la grandezza più elevata tra due numeri a virgola mobile e precisione doppia.
Min(Byte, Byte)

Restituisce il meno elevato tra due interi senza segno a 8 bit.
Min(Decimal, Decimal)

Restituisce il meno elevato tra due numeri decimali.
Min(Double, Double)

Restituisce il meno elevato tra due numeri a virgola mobile e precisione doppia.
Min(Int16, Int16)

Restituisce il meno elevato tra due interi con segno a 16 bit.
Min(Int32, Int32)

Restituisce il meno elevato tra due interi con segno a 32 bit.
Min(Int64, Int64)

Restituisce il meno elevato tra due interi con segno a 64 bit.
Min(IntPtr, IntPtr)

Restituisce il più piccolo di due interi con segno nativi.
Min(SByte, SByte)

Restituisce il meno elevato tra due interi con segno a 8 bit.
Min(Single, Single)

Restituisce il meno elevato tra due numeri a virgola mobile e precisione singola.
Min(UInt16, UInt16)

Restituisce il meno elevato tra due interi senza segno a 16 bit.
Min(UInt32, UInt32)

Restituisce il meno elevato tra due interi senza segno a 32 bit.
Min(UInt64, UInt64)

Restituisce il meno elevato tra due interi senza segno a 64 bit.
Min(UIntPtr, UIntPtr)

Restituisce il più piccolo di due interi senza segno nativi.
MinMagnitude(Double, Double)

Restituisce la grandezza meno elevata tra due numeri a virgola mobile e precisione doppia.
Pow(Double, Double)

Restituisce il numero specificato elevato alla potenza specificata.
ReciprocalEstimate(Double)

Restituisce una stima del reciproco di un numero specificato.
ReciprocalSqrtEstimate(Double)

Restituisce una stima della radice quadrata reciproca di un numero specificato.
Round(Decimal)

Arrotonda un valore decimale al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.
Round(Decimal, Int32)

Arrotonda un valore decimale del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.
Round(Decimal, Int32, MidpointRounding)

Arrotonda un valore decimale a un numero specificato di cifre frazionarie utilizzando la convenzione di arrotondamento specificata.
Round(Decimal, MidpointRounding)

Arrotonda un valore decimale a un intero utilizzando la convenzione di arrotondamento specificata.
Round(Double)

Arrotonda un valore a virgola mobile e precisione doppia al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.
Round(Double, Int32)

Arrotonda un valore a virgola mobile e precisione doppia del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.
Round(Double, Int32, MidpointRounding)

Arrotonda un valore a virgola mobile e precisione doppia a un numero specificato di cifre frazionarie usando la convenzione di arrotondamento specificata.
Round(Double, MidpointRounding)

Arrotonda un valore a virgola mobile e precisione doppia a un intero usando la convenzione di arrotondamento specificata.
ScaleB(Double, Int32)

Restituisce x * 2^n calcolato in modo efficiente.
Sign(Decimal)

Restituisce un intero che indica il segno di un numero decimale.
Sign(Double)

Restituisce un intero che indica il segno di un numero a virgola mobile e a precisione doppia.
Sign(Int16)

Restituisce un intero che indica il segno di un intero con firma a 16 bit.
Sign(Int32)

Restituisce un intero che indica il segno di un intero con segno a 32 bit.
Sign(Int64)

Restituisce un intero che indica il segno di un intero con segno a 64 bit.
Sign(IntPtr)

Restituisce un intero che indica il segno di un intero con segno di dimensioni native.
Sign(SByte)

Restituisce un intero che indica il segno di un intero con segno a 8 bit.
Sign(Single)

Restituisce un intero che indica il segno di un numero a virgola mobile e a precisione singola.
Sin(Double)

Restituisce il seno dell'angolo specificato.
SinCos(Double)

Restituisce il seno e il coseno dell'angolo specificato.
Sinh(Double)

Restituisce il seno iperbolico dell'angolo specificato.
Sqrt(Double)

Restituisce la radice quadrata del numero specificato.
Tan(Double)

Restituisce la tangente dell'angolo specificato.
Tanh(Double)

Restituisce la tangente iperbolica dell'angolo specificato.
Truncate(Decimal)

Calcola la parte integrale di un numero decimale specificato.
Truncate(Double)

Calcola la parte integrale di un numero a virgola mobile e precisione doppia specificato.

Si applica a