Math Classe

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Fornisce costanti e metodi statici per funzioni matematiche trigonometriche, logaritmiche e altre funzioni matematiche comuni.

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 Math per calcolare gli angoli interni di un trapezoio.

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

Campi

E	Rappresenta la base logaritmica naturale, specificata dalla costante `e`.
PI	Rappresenta il rapporto tra la circonferenza di un cerchio e il relativo diametro, specificata dalla costante π.
Tau	Rappresenta il numero di radianti in un turno, specificato 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 di cui la tangente iperbolica è il numero specificato.
BigMul(Int32, Int32)	Produce il prodotto completo di due numeri a 32 bit.
BigMul(Int64, Int64)	Produce il prodotto completo di due numeri a 64 bit.
BigMul(Int64, Int64, Int64)	Produce il prodotto completo di due numeri a 64 bit.
BigMul(UInt32, UInt32)	Produce il prodotto completo di due numeri a 32 bit senza segno.
BigMul(UInt64, UInt64)	Produce il prodotto completo di due numeri senza segno a 64 bit.
BigMul(UInt64, UInt64, UInt64)	Produce il prodotto completo di due numeri senza segno a 64 bit.
BitDecrement(Double)	Restituisce il valore più grande che confronta meno di un valore specificato.
BitIncrement(Double)	Restituisce il valore più piccolo che confronta un valore maggiore di un valore specificato.
Cbrt(Double)	Restituisce la radice del cubo di un numero specificato.
Ceiling(Decimal)	Restituisce il valore integrale più piccolo maggiore o uguale al numero decimale specificato.
Ceiling(Double)	Restituisce il valore integrale più piccolo maggiore o uguale al numero a virgola mobile a precisione doppia specificato.
Clamp(Byte, Byte, Byte)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(Decimal, Decimal, Decimal)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(Double, Double, Double)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(Int16, Int16, Int16)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(Int32, Int32, Int32)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(Int64, Int64, Int64)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(IntPtr, IntPtr, IntPtr)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(SByte, SByte, SByte)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(Single, Single, Single)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(UInt16, UInt16, UInt16)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(UInt32, UInt32, UInt32)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(UInt64, UInt64, UInt64)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
Clamp(UIntPtr, UIntPtr, UIntPtr)	Restituisce `value` bloccato all'intervallo inclusivo di `min` e `max`.
CopySign(Double, Double)	Restituisce un valore con la grandezza di `x` e il segno di `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 senza segno a 8 bit.
DivRem(Int16, Int16)	Produce il quoziente e il resto di due numeri a 16 bit firmati.
DivRem(Int32, Int32)	Produce il quoziente e il resto di due numeri a 32 bit firmati.
DivRem(Int32, Int32, Int32)	Calcola il quoziente di due interi con segno a 32 bit e restituisce anche il resto in un parametro di output.
DivRem(Int64, Int64)	Produce il quoziente e il resto di due numeri a 64 bit firmati.
DivRem(Int64, Int64, Int64)	Calcola il quoziente di due interi con segno a 64 bit e restituisce anche il resto in un parametro di output.
DivRem(IntPtr, IntPtr)	Produce il quoziente e il resto di due numeri di dimensioni native firmate.
DivRem(SByte, SByte)	Produce il quoziente e il resto di due numeri a 8 bit firmati.
DivRem(UInt16, UInt16)	Produce il quoziente e il resto di due numeri senza segno a 16 bit.
DivRem(UInt32, UInt32)	Produce il quoziente e il resto di due numeri senza segno a 32 bit.
DivRem(UInt64, UInt64)	Produce il quoziente e il resto di due numeri senza segno a 64 bit.
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 più grande minore o uguale al numero decimale specificato.
Floor(Double)	Restituisce il valore integrale più grande minore o uguale al numero a virgola mobile a precisione doppia specificato.
FusedMultiplyAdd(Double, Double, Double)	Restituisce (x * y) + z, arrotondato come un'operazione ternaria.
IEEERemainder(Double, Double)	Restituisce il resto risultante dalla divisione di un numero specificato in base a un altro numero specificato.
ILogB(Double)	Restituisce il logaritmo intero in base 2 di un numero specificato.
Log(Double)	Restituisce il logaritmo naturale (base `e`) di un numero specificato.
Log(Double, Double)	Restituisce il logaritmo di un numero specificato in una base specificata.
Log10(Double)	Restituisce il logaritmo di base 10 di un numero specificato.
Log2(Double)	Restituisce il logaritmo in base 2 di un numero specificato.
Max(Byte, Byte)	Restituisce il valore maggiore di due interi senza segno a 8 bit.
Max(Decimal, Decimal)	Restituisce il valore più grande di due numeri decimali.
Max(Double, Double)	Restituisce il valore maggiore di due numeri a virgola mobile e precisione doppia.
Max(Int16, Int16)	Restituisce il valore maggiore di due interi con segno a 16 bit.
Max(Int32, Int32)	Restituisce il valore maggiore di due interi con segno a 32 bit.
Max(Int64, Int64)	Restituisce il valore maggiore di due interi con segno a 64 bit.
Max(IntPtr, IntPtr)	Restituisce il valore maggiore di due interi con segno nativo.
Max(SByte, SByte)	Restituisce il valore maggiore di due interi con segno a 8 bit.
Max(Single, Single)	Restituisce il valore maggiore di due numeri a virgola mobile e precisione singola.
Max(UInt16, UInt16)	Restituisce il valore maggiore di due interi senza segno a 16 bit.
Max(UInt32, UInt32)	Restituisce il valore maggiore di due interi senza segno a 32 bit.
Max(UInt64, UInt64)	Restituisce il valore maggiore di due interi senza segno a 64 bit.
Max(UIntPtr, UIntPtr)	Restituisce il più grande di due interi senza segno nativi.
MaxMagnitude(Double, Double)	Restituisce la grandezza maggiore di due numeri a virgola mobile e precisione doppia.
Min(Byte, Byte)	Restituisce il più piccolo di due interi senza segno a 8 bit.
Min(Decimal, Decimal)	Restituisce il più piccolo di due numeri decimali.
Min(Double, Double)	Restituisce il più piccolo di due numeri a virgola mobile e precisione doppia.
Min(Int16, Int16)	Restituisce il più piccolo di due interi con segno a 16 bit.
Min(Int32, Int32)	Restituisce il più piccolo di due interi con segno a 32 bit.
Min(Int64, Int64)	Restituisce il più piccolo di due interi con segno a 64 bit.
Min(IntPtr, IntPtr)	Restituisce il più piccolo di due interi con segno nativo.
Min(SByte, SByte)	Restituisce il più piccolo di due interi con segno a 8 bit.
Min(Single, Single)	Restituisce il più piccolo di due numeri a virgola mobile e precisione singola.
Min(UInt16, UInt16)	Restituisce il più piccolo di due interi senza segno a 16 bit.
Min(UInt32, UInt32)	Restituisce il più piccolo di due interi senza segno a 32 bit.
Min(UInt64, UInt64)	Restituisce il più piccolo di 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 inferiore di due numeri a virgola mobile e precisione doppia.
Pow(Double, Double)	Restituisce un 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 del punto medio al numero pari più vicino.
Round(Decimal, Int32)	Arrotonda un valore decimale a un numero specificato di cifre frazionarie e arrotonda i valori del punto medio al numero pari più vicino.
Round(Decimal, Int32, MidpointRounding)	Arrotonda un valore decimale a un numero specificato di cifre frazionarie usando la convenzione di arrotondamento specificata.
Round(Decimal, MidpointRounding)	Arrotonda un valore decimale un numero 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 del punto medio al numero pari più vicino.
Round(Double, Int32)	Arrotonda un valore a virgola mobile e precisione doppia a un numero specificato di cifre frazionarie e arrotonda i valori del punto medio 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 calcolata in modo efficiente.
Sign(Decimal)	Restituisce un numero intero che indica il segno di un numero decimale.
Sign(Double)	Restituisce un numero intero che indica il segno di un numero a virgola mobile e precisione doppia.
Sign(Int16)	Restituisce un intero che indica il segno di un intero con segno 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 numero intero che indica il segno di un intero con segno con dimensioni native.
Sign(SByte)	Restituisce un intero che indica il segno di un intero con segno a 8 bit.
Sign(Single)	Restituisce un numero intero che indica il segno di un numero a virgola mobile e 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 di un numero specificato.
Tan(Double)	Restituisce la tangente dell'angolo specificato.
Tanh(Double)	Restituisce la tangente iperbolica dell'angolo specificato.
Truncate(Decimal)	Calcola la parte integrante di un numero decimale specificato.
Truncate(Double)	Calcola la parte integrante di un numero a virgola mobile e precisione doppia specificato.

Si applica a

Condividi tramite