Math Classe

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Fournit des constantes et des méthodes statiques pour les fonctions mathématiques trigonométriques, logarithmiques et autres fonctions mathématiques courantes.

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

Héritage: Object
Math

Exemples

L’exemple suivant utilise plusieurs fonctions mathématiques et trigonométriques de la classe Math pour calculer les angles internes d’un trapézoïde.

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

Champs

E	Représente la base logarithmique naturelle, spécifiée par la constante, `e`.
PI	Représente le rapport de la circonférence d’un cercle à son diamètre, spécifié par la constante, π.
Tau	Représente le nombre de radians à un tour, spécifié par la constante, τ.

Méthodes

Abs(Decimal)	Retourne la valeur absolue d’un nombre Decimal.
Abs(Double)	Retourne la valeur absolue d’un nombre à virgule flottante double précision.
Abs(Int16)	Retourne la valeur absolue d’un entier signé 16 bits.
Abs(Int32)	Retourne la valeur absolue d’un entier signé 32 bits.
Abs(Int64)	Retourne la valeur absolue d’un entier signé 64 bits.
Abs(IntPtr)	Retourne la valeur absolue d’un entier signé natif.
Abs(SByte)	Retourne la valeur absolue d’un entier signé 8 bits.
Abs(Single)	Retourne la valeur absolue d’un nombre à virgule flottante simple précision.
Acos(Double)	Retourne l’angle dont le cosinus est le nombre spécifié.
Acosh(Double)	Retourne l’angle dont le cosinus hyperbolique est le nombre spécifié.
Asin(Double)	Retourne l’angle dont le sinus est le nombre spécifié.
Asinh(Double)	Retourne l’angle dont le sinus hyperbolique est le nombre spécifié.
Atan(Double)	Retourne l’angle dont la tangente est le nombre spécifié.
Atan2(Double, Double)	Retourne l’angle dont la tangente est le quotient de deux nombres spécifiés.
Atanh(Double)	Retourne l’angle dont la tangente hyperbolique est le nombre spécifié.
BigMul(Int32, Int32)	Produit le produit complet de deux nombres 32 bits.
BigMul(Int64, Int64)	Produit le produit complet de deux nombres 64 bits.
BigMul(Int64, Int64, Int64)	Produit le produit complet de deux nombres 64 bits.
BigMul(UInt32, UInt32)	Produit le produit complet de deux nombres 32 bits non signés.
BigMul(UInt64, UInt64)	Produit le produit complet de deux nombres 64 bits non signés.
BigMul(UInt64, UInt64, UInt64)	Produit le produit complet de deux nombres 64 bits non signés.
BitDecrement(Double)	Retourne la plus grande valeur qui compare moins qu’une valeur spécifiée.
BitIncrement(Double)	Retourne la plus petite valeur qui compare une valeur supérieure à une valeur spécifiée.
Cbrt(Double)	Retourne la racine du cube d’un nombre spécifié.
Ceiling(Decimal)	Retourne la plus petite valeur intégrale supérieure ou égale au nombre décimal spécifié.
Ceiling(Double)	Retourne la plus petite valeur intégrale supérieure ou égale au nombre à virgule flottante double précision spécifié.
Clamp(Byte, Byte, Byte)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(Decimal, Decimal, Decimal)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(Double, Double, Double)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(Int16, Int16, Int16)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(Int32, Int32, Int32)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(Int64, Int64, Int64)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(IntPtr, IntPtr, IntPtr)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(SByte, SByte, SByte)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(Single, Single, Single)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(UInt16, UInt16, UInt16)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(UInt32, UInt32, UInt32)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(UInt64, UInt64, UInt64)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
Clamp(UIntPtr, UIntPtr, UIntPtr)	Retourne `value` limitée à la plage inclusive de `min` et de `max`.
CopySign(Double, Double)	Retourne une valeur avec l’ampleur de `x` et le signe de `y`.
Cos(Double)	Retourne le cosinus de l’angle spécifié.
Cosh(Double)	Retourne le cosinus hyperbolique de l’angle spécifié.
DivRem(Byte, Byte)	Produit le quotient et le reste de deux nombres 8 bits non signés.
DivRem(Int16, Int16)	Produit le quotient et le reste de deux nombres 16 bits signés.
DivRem(Int32, Int32)	Produit le quotient et le reste de deux nombres 32 bits signés.
DivRem(Int32, Int32, Int32)	Calcule le quotient de deux entiers signés 32 bits et retourne également le reste dans un paramètre de sortie.
DivRem(Int64, Int64)	Produit le quotient et le reste de deux nombres 64 bits signés.
DivRem(Int64, Int64, Int64)	Calcule le quotient de deux entiers signés 64 bits et retourne également le reste dans un paramètre de sortie.
DivRem(IntPtr, IntPtr)	Produit le quotient et le reste de deux nombres de taille native signés.
DivRem(SByte, SByte)	Produit le quotient et le reste de deux nombres 8 bits signés.
DivRem(UInt16, UInt16)	Produit le quotient et le reste de deux nombres 16 bits non signés.
DivRem(UInt32, UInt32)	Produit le quotient et le reste de deux nombres 32 bits non signés.
DivRem(UInt64, UInt64)	Produit le quotient et le reste de deux nombres 64 bits non signés.
DivRem(UIntPtr, UIntPtr)	Produit le quotient et le reste de deux nombres de taille native non signés.
Exp(Double)	Retourne `e` déclenché à la puissance spécifiée.
Floor(Decimal)	Retourne la plus grande valeur intégrale inférieure ou égale au nombre décimal spécifié.
Floor(Double)	Retourne la plus grande valeur intégrale inférieure ou égale au nombre à virgule flottante double précision spécifié.
FusedMultiplyAdd(Double, Double, Double)	Renvoie (x * y) + z, arrondi en une seule opération ternaire.
IEEERemainder(Double, Double)	Retourne le reste résultant de la division d’un nombre spécifié par un autre nombre spécifié.
ILogB(Double)	Retourne le logarithme de base 2 entiers d’un nombre spécifié.
Log(Double)	Retourne le logarithme naturel (base `e`) d’un nombre spécifié.
Log(Double, Double)	Retourne le logarithme d’un nombre spécifié dans une base spécifiée.
Log10(Double)	Retourne le logarithme de base 10 d’un nombre spécifié.
Log2(Double)	Retourne le logarithme de base 2 d’un nombre spécifié.
Max(Byte, Byte)	Retourne la plus grande de deux entiers non signés 8 bits.
Max(Decimal, Decimal)	Retourne la plus grande de deux nombres décimaux.
Max(Double, Double)	Retourne la plus grande de deux nombres à virgule flottante double précision.
Max(Int16, Int16)	Retourne la plus grande de deux entiers signés 16 bits.
Max(Int32, Int32)	Retourne la plus grande de deux entiers signés 32 bits.
Max(Int64, Int64)	Retourne la plus grande de deux entiers signés 64 bits.
Max(IntPtr, IntPtr)	Retourne la plus grande de deux entiers signés natifs.
Max(SByte, SByte)	Retourne la plus grande de deux entiers signés 8 bits.
Max(Single, Single)	Retourne la plus grande de deux nombres à virgule flottante simple précision.
Max(UInt16, UInt16)	Retourne la plus grande de deux entiers non signés 16 bits.
Max(UInt32, UInt32)	Retourne la plus grande de deux entiers non signés 32 bits.
Max(UInt64, UInt64)	Retourne la plus grande de deux entiers non signés 64 bits.
Max(UIntPtr, UIntPtr)	Retourne la plus grande de deux entiers non signés natifs.
MaxMagnitude(Double, Double)	Retourne la plus grande magnitude de deux nombres à virgule flottante double précision.
Min(Byte, Byte)	Retourne la plus petite de deux entiers non signés 8 bits.
Min(Decimal, Decimal)	Retourne la plus petite de deux nombres décimaux.
Min(Double, Double)	Retourne la plus petite de deux nombres à virgule flottante double précision.
Min(Int16, Int16)	Retourne la plus petite de deux entiers signés 16 bits.
Min(Int32, Int32)	Retourne la plus petite de deux entiers signés 32 bits.
Min(Int64, Int64)	Retourne la plus petite de deux entiers signés 64 bits.
Min(IntPtr, IntPtr)	Retourne la plus petite de deux entiers signés natifs.
Min(SByte, SByte)	Retourne la plus petite de deux entiers signés 8 bits.
Min(Single, Single)	Retourne la plus petite de deux nombres à virgule flottante simple précision.
Min(UInt16, UInt16)	Retourne la plus petite de deux entiers non signés 16 bits.
Min(UInt32, UInt32)	Retourne la plus petite de deux entiers non signés 32 bits.
Min(UInt64, UInt64)	Retourne la plus petite de deux entiers non signés 64 bits.
Min(UIntPtr, UIntPtr)	Retourne la plus petite de deux entiers non signés natifs.
MinMagnitude(Double, Double)	Retourne la plus petite magnitude de deux nombres à virgule flottante double précision.
Pow(Double, Double)	Retourne un nombre spécifié déclenché à la puissance spécifiée.
ReciprocalEstimate(Double)	Retourne une estimation de la réciproque d’un nombre spécifié.
ReciprocalSqrtEstimate(Double)	Retourne une estimation de la racine carrée réciproque d’un nombre spécifié.
Round(Decimal)	Arrondit une valeur décimale à la valeur intégrale la plus proche et arrondit les valeurs intermédiaires au nombre pair le plus proche.
Round(Decimal, Int32)	Arrondit une valeur décimale à un nombre spécifié de chiffres fractionnaires, et arrondit les valeurs intermédiaires au nombre pair le plus proche.
Round(Decimal, Int32, MidpointRounding)	Arrondit une valeur décimale à un nombre spécifié de chiffres fractionnaires à l’aide de la convention d’arrondi spécifiée.
Round(Decimal, MidpointRounding)	Arrondit une valeur décimale un entier à l’aide de la convention d’arrondi spécifiée.
Round(Double)	Arrondit une valeur à virgule flottante double précision à la valeur intégrale la plus proche et arrondit les valeurs intermédiaires au nombre pair le plus proche.
Round(Double, Int32)	Arrondit une valeur à virgule flottante double précision à un nombre spécifié de chiffres fractionnaires et arrondit les valeurs intermédiaires au nombre pair le plus proche.
Round(Double, Int32, MidpointRounding)	Arrondit une valeur à virgule flottante double précision à un nombre spécifié de chiffres fractionnaires à l’aide de la convention d’arrondi spécifiée.
Round(Double, MidpointRounding)	Arrondit une valeur à virgule flottante double précision à un entier à l’aide de la convention d’arrondi spécifiée.
ScaleB(Double, Int32)	Retourne x * 2^n calculé efficacement.
Sign(Decimal)	Retourne un entier qui indique le signe d’un nombre décimal.
Sign(Double)	Retourne un entier qui indique le signe d’un nombre à virgule flottante double précision.
Sign(Int16)	Retourne un entier qui indique le signe d’un entier signé 16 bits.
Sign(Int32)	Retourne un entier qui indique le signe d’un entier signé 32 bits.
Sign(Int64)	Retourne un entier qui indique le signe d’un entier signé 64 bits.
Sign(IntPtr)	Retourne un entier qui indique le signe d’un entier signé de taille native.
Sign(SByte)	Retourne un entier qui indique le signe d’un entier signé 8 bits.
Sign(Single)	Retourne un entier qui indique le signe d’un nombre à virgule flottante simple précision.
Sin(Double)	Retourne le sinus de l’angle spécifié.
SinCos(Double)	Retourne le sinus et le cosinus de l’angle spécifié.
Sinh(Double)	Retourne le sinus hyperbolique de l’angle spécifié.
Sqrt(Double)	Retourne la racine carrée d’un nombre spécifié.
Tan(Double)	Retourne la tangente de l’angle spécifié.
Tanh(Double)	Retourne la tangente hyperbolique de l’angle spécifié.
Truncate(Decimal)	Calcule la partie intégrale d’un nombre décimal spécifié.
Truncate(Double)	Calcule la partie intégrale d’un nombre à virgule flottante double précision spécifié.

S’applique à

Partage via