Math Klasse

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Quelle:: Math.cs

Quelle:: Math.cs

Quelle:: Math.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt Konstanten und statische Methoden für trigonometrische, logarithmische und andere allgemeine mathematische Funktionen bereit.

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

Vererbung: Object
Math

Beispiele

Im folgenden Beispiel werden mehrere mathematische und trigonometrische Funktionen aus der klasse Math verwendet, um die inneren Winkel eines Trapezoids zu berechnen.

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

Felder

E	Stellt die natürliche logarithmische Basis dar, die durch die Konstante angegeben wird, `e`.
PI	Stellt das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser dar, der durch die Konstante angegeben wird, π.
Tau	Stellt die Anzahl der Bogenmaße in einer Drehzahl dar, die durch die Konstante τ angegeben wird.

Methoden

Abs(Decimal)	Gibt den absoluten Wert einer Decimal Zahl zurück.
Abs(Double)	Gibt den absoluten Wert einer Gleitkommazahl mit doppelter Genauigkeit zurück.
Abs(Int16)	Gibt den absoluten Wert einer 16-Bit-ganzzahligen Vorzeichen zurück.
Abs(Int32)	Gibt den absoluten Wert einer 32-Bit-ganzzahligen Vorzeichen zurück.
Abs(Int64)	Gibt den absoluten Wert einer ganzzahligen 64-Bit-Vorzeichen zurück.
Abs(IntPtr)	Gibt den absoluten Wert einer systemeigenen vorzeichenigen ganzzahligen Zahl zurück.
Abs(SByte)	Gibt den absoluten Wert einer 8-Bit-ganzzahligen Vorzeichen zurück.
Abs(Single)	Gibt den absoluten Wert einer Gleitkommazahl mit einfacher Genauigkeit zurück.
Acos(Double)	Gibt den Winkel zurück, dessen Kosinus die angegebene Zahl ist.
Acosh(Double)	Gibt den Winkel zurück, dessen hyperbolischer Kosinus die angegebene Zahl ist.
Asin(Double)	Gibt den Winkel zurück, dessen Sinus die angegebene Zahl ist.
Asinh(Double)	Gibt den Winkel zurück, dessen hyperbolischer Sinus die angegebene Zahl ist.
Atan(Double)	Gibt den Winkel zurück, dessen Tangens die angegebene Zahl ist.
Atan2(Double, Double)	Gibt den Winkel zurück, dessen Tangens der Quotient von zwei angegebenen Zahlen ist.
Atanh(Double)	Gibt den Winkel zurück, dessen hyperbolischer Tangens die angegebene Zahl ist.
BigMul(Int32, Int32)	Produziert das gesamte Produkt von zwei 32-Bit-Zahlen.
BigMul(Int64, Int64)	Produziert das gesamte Produkt von zwei 64-Bit-Zahlen.
BigMul(Int64, Int64, Int64)	Produziert das gesamte Produkt von zwei 64-Bit-Zahlen.
BigMul(UInt32, UInt32)	Produziert das vollständige Produkt von zwei nicht signierten 32-Bit-Nummern.
BigMul(UInt64, UInt64)	Produziert das gesamte Produkt von zwei nicht signierten 64-Bit-Nummern.
BigMul(UInt64, UInt64, UInt64)	Produziert das gesamte Produkt von zwei nicht signierten 64-Bit-Nummern.
BitDecrement(Double)	Gibt den größten Wert zurück, der kleiner als ein angegebener Wert ist.
BitIncrement(Double)	Gibt den kleinsten Wert zurück, der größer als ein angegebener Wert ist.
Cbrt(Double)	Gibt den Cubestamm einer angegebenen Zahl zurück.
Ceiling(Decimal)	Gibt den kleinsten integralen Wert zurück, der größer oder gleich der angegebenen Dezimalzahl ist.
Ceiling(Double)	Gibt den kleinsten integralen Wert zurück, der größer oder gleich der angegebenen Gleitkommazahl mit doppelter Genauigkeit ist.
Clamp(Byte, Byte, Byte)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(Decimal, Decimal, Decimal)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(Double, Double, Double)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(Int16, Int16, Int16)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(Int32, Int32, Int32)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(Int64, Int64, Int64)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(IntPtr, IntPtr, IntPtr)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(SByte, SByte, SByte)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(Single, Single, Single)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(UInt16, UInt16, UInt16)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(UInt32, UInt32, UInt32)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(UInt64, UInt64, UInt64)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
Clamp(UIntPtr, UIntPtr, UIntPtr)	Gibt `value` an den inklusiven Bereich von `min` und `max`geklemmt zurück.
CopySign(Double, Double)	Gibt einen Wert mit der Größe von `x` und dem Vorzeichen von `y`zurück.
Cos(Double)	Gibt den Kosinus des angegebenen Winkels zurück.
Cosh(Double)	Gibt den hyperbolischen Kosinus des angegebenen Winkels zurück.
DivRem(Byte, Byte)	Erzeugt den Quotienten und den Rest von zwei nicht signierten 8-Bit-Zahlen.
DivRem(Int16, Int16)	Erzeugt den Quotienten und den Rest von zwei signierten 16-Bit-Zahlen.
DivRem(Int32, Int32)	Erzeugt den Quotienten und den Rest von zwei signierten 32-Bit-Zahlen.
DivRem(Int32, Int32, Int32)	Berechnet den Quotient von zwei 32-Bit-ganzzahligen Vorzeichen und gibt auch den Rest in einem Ausgabeparameter zurück.
DivRem(Int64, Int64)	Erzeugt den Quotient und den Rest von zwei signierten 64-Bit-Zahlen.
DivRem(Int64, Int64, Int64)	Berechnet den Quotient von zwei 64-Bit-ganzzahligen Vorzeichen und gibt auch den Rest in einem Ausgabeparameter zurück.
DivRem(IntPtr, IntPtr)	Erzeugt den Quotient und den Rest von zwei signierten zahlen nativen Größen.
DivRem(SByte, SByte)	Erzeugt den Quotienten und den Rest von zwei signierten 8-Bit-Zahlen.
DivRem(UInt16, UInt16)	Erzeugt den Quotient und den Rest von zwei nicht signierten 16-Bit-Zahlen.
DivRem(UInt32, UInt32)	Erzeugt den Quotient und den Rest von zwei nicht signierten 32-Bit-Zahlen.
DivRem(UInt64, UInt64)	Erzeugt den Quotienten und den Rest von zwei nicht signierten 64-Bit-Zahlen.
DivRem(UIntPtr, UIntPtr)	Erzeugt den Quotienten und den Rest von zwei nicht signierten zahlen nativen Größen.
Exp(Double)	Gibt `e` an die angegebene Potenz angehoben zurück.
Floor(Decimal)	Gibt den größten integralen Wert kleiner oder gleich der angegebenen Dezimalzahl zurück.
Floor(Double)	Gibt den größten integralen Wert zurück, der kleiner oder gleich der angegebenen Gleitkommazahl mit doppelter Genauigkeit ist.
FusedMultiplyAdd(Double, Double, Double)	Gibt (x * y) + z zurück, gerundet als ein ternärer Vorgang.
IEEERemainder(Double, Double)	Gibt den Rest zurück, der sich aus der Division einer angegebenen Zahl durch eine andere angegebene Zahl ergibt.
ILogB(Double)	Gibt den Logarithmus der Basis 2 einer angegebenen Zahl zurück.
Log(Double)	Gibt den natürlichen Logarithmus (Basis `e`) einer angegebenen Zahl zurück.
Log(Double, Double)	Gibt den Logarithmus einer angegebenen Zahl in einer angegebenen Basis zurück.
Log10(Double)	Gibt den Logarithmus der Basis 10 einer angegebenen Zahl zurück.
Log2(Double)	Gibt den Logarithmus der Basis 2 einer angegebenen Zahl zurück.
Max(Byte, Byte)	Gibt die größer als zwei 8-Bit-Ganzzahlen ohne Vorzeichen zurück.
Max(Decimal, Decimal)	Gibt die größer als zwei Dezimalzahlen zurück.
Max(Double, Double)	Gibt die größer als zwei Gleitkommazahlen mit doppelter Genauigkeit zurück.
Max(Int16, Int16)	Gibt die größer als zwei 16-Bit-Ganzzahlen zurück.
Max(Int32, Int32)	Gibt die größer als zwei 32-Bit-Ganzzahlen zurück.
Max(Int64, Int64)	Gibt die größer als zwei 64-Bit-Ganzzahlen zurück.
Max(IntPtr, IntPtr)	Gibt die größer als zwei systemeigene vorzeichenbehaftete ganzzahlige Zahlen zurück.
Max(SByte, SByte)	Gibt die größer als zwei 8-Bit-Ganzzahlen zurück.
Max(Single, Single)	Gibt die größer als zwei Gleitkommazahlen mit einfacher Genauigkeit zurück.
Max(UInt16, UInt16)	Gibt die größer als zwei 16-Bit-ganzzahlen ohne Vorzeichen zurück.
Max(UInt32, UInt32)	Gibt die größer als zwei 32-Bit-Ganzzahlen ohne Vorzeichen zurück.
Max(UInt64, UInt64)	Gibt die größer als zwei 64-Bit-Ganzzahlen ohne Vorzeichen zurück.
Max(UIntPtr, UIntPtr)	Gibt die größere Zahl von zwei nativen nicht signierten Ganzzahlen zurück.
MaxMagnitude(Double, Double)	Gibt die größere Größe von zwei Gleitkommazahlen mit doppelter Genauigkeit zurück.
Min(Byte, Byte)	Gibt die kleinere von zwei 8-Bit-ganzzahlen ohne Vorzeichen zurück.
Min(Decimal, Decimal)	Gibt die kleineren von zwei Dezimalzahlen zurück.
Min(Double, Double)	Gibt die kleineren zwei Gleitkommazahlen mit doppelter Genauigkeit zurück.
Min(Int16, Int16)	Gibt die kleineren zwei 16-Bit-Ganzzahlen zurück.
Min(Int32, Int32)	Gibt die kleineren zwei 32-Bit-Ganzzahlen zurück.
Min(Int64, Int64)	Gibt die kleineren zwei 64-Bit-Ganzzahlen zurück.
Min(IntPtr, IntPtr)	Gibt die kleineren von zwei nativen vorzeichenierten Ganzzahlen zurück.
Min(SByte, SByte)	Gibt die kleineren zwei 8-Bit-Ganzzahlen zurück.
Min(Single, Single)	Gibt die kleineren zwei Gleitkommazahlen mit einfacher Genauigkeit zurück.
Min(UInt16, UInt16)	Gibt die kleinere von zwei 16-Bit-ganzzahlen ohne Vorzeichen zurück.
Min(UInt32, UInt32)	Gibt die kleinere von zwei 32-Bit-ganzzahlen ohne Vorzeichen zurück.
Min(UInt64, UInt64)	Gibt die kleineren zwei ganzzahligen 64-Bit-Zahlen zurück.
Min(UIntPtr, UIntPtr)	Gibt die kleineren zwei systemeigenen ganzzahligen ganzzahligen Zahlen zurück.
MinMagnitude(Double, Double)	Gibt die kleinere Größe von zwei Gleitkommazahlen mit doppelter Genauigkeit zurück.
Pow(Double, Double)	Gibt eine angegebene Zahl zurück, die an die angegebene Potenz ausgelöst wird.
ReciprocalEstimate(Double)	Gibt eine Schätzung des Kehrwerts einer angegebenen Zahl zurück.
ReciprocalSqrtEstimate(Double)	Gibt eine Schätzung der gegenseitigen Quadratwurzel einer angegebenen Zahl zurück.
Round(Decimal)	Rundet einen Dezimalwert auf den nächstgelegenen integralen Wert und rundet Die Mittelpunktswerte auf die nächste gerade Zahl ab.
Round(Decimal, Int32)	Rundet einen Dezimalwert auf eine angegebene Anzahl von Dezimalstellen ab und rundet Mittelpunktswerte auf die nächste gerade Zahl ab.
Round(Decimal, Int32, MidpointRounding)	Rundet einen Dezimalwert auf eine angegebene Anzahl von Dezimalstellen mithilfe der angegebenen Rundungskonvention ab.
Round(Decimal, MidpointRounding)	Rundet einen Dezimalwert auf eine ganze Zahl mithilfe der angegebenen Rundungskonvention.
Round(Double)	Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächsten integralen Wert ab und rundet Mittelpunktswerte auf die nächste gerade Zahl.
Round(Double, Int32)	Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl von Dezimalstellen ab und rundet die Mittelpunktswerte auf die nächste gerade Zahl.
Round(Double, Int32, MidpointRounding)	Rundet mithilfe der angegebenen Rundungskonvention einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl von Bruchstellen ab.
Round(Double, MidpointRounding)	Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine ganze Zahl mithilfe der angegebenen Rundungskonvention ab.
ScaleB(Double, Int32)	Gibt x * 2^n effizient berechnet zurück.
Sign(Decimal)	Gibt eine ganze Zahl zurück, die das Vorzeichen einer Dezimalzahl angibt.
Sign(Double)	Gibt eine ganze Zahl zurück, die das Vorzeichen einer Gleitkommazahl mit doppelter Genauigkeit angibt.
Sign(Int16)	Gibt eine ganze Zahl zurück, die das Vorzeichen einer 16-Bit-ganzzahligen Vorzeichen angibt.
Sign(Int32)	Gibt eine ganze Zahl zurück, die das Vorzeichen einer ganzzahligen 32-Bit-Vorzeichen angibt.
Sign(Int64)	Gibt eine ganze Zahl zurück, die das Vorzeichen einer ganzzahligen 64-Bit-Vorzeichen angibt.
Sign(IntPtr)	Gibt eine ganze Zahl zurück, die das Vorzeichen einer signierten ganzzahligen Größe angibt.
Sign(SByte)	Gibt eine ganze Zahl zurück, die das Vorzeichen einer 8-Bit-Ganzzahl angibt.
Sign(Single)	Gibt eine ganze Zahl zurück, die das Vorzeichen einer Gleitkommazahl mit einfacher Genauigkeit angibt.
Sin(Double)	Gibt den Sinus des angegebenen Winkels zurück.
SinCos(Double)	Gibt den Sinus und kosinus des angegebenen Winkels zurück.
Sinh(Double)	Gibt den hyperbolischen Sinus des angegebenen Winkels zurück.
Sqrt(Double)	Gibt die Quadratwurzel einer angegebenen Zahl zurück.
Tan(Double)	Gibt den Tangens des angegebenen Winkels zurück.
Tanh(Double)	Gibt den hyperbolischen Tangens des angegebenen Winkels zurück.
Truncate(Decimal)	Berechnet den integralen Teil einer angegebenen Dezimalzahl.
Truncate(Double)	Berechnet den integralen Teil einer angegebenen Gleitkommazahl mit doppelter Genauigkeit.

Gilt für:

Freigeben über