Math Klass

Definition

Namnområde:
System
Sammansättningar:
mscorlib.dll, System.Runtime.Extensions.dll
Sammansättningar:
netstandard.dll, System.Runtime.dll
Sammansättning:
System.Runtime.Extensions.dll
Sammansättning:
mscorlib.dll
Sammansättning:
netstandard.dll
Källa:
Math.cs
Källa:
Math.cs
Källa:
Math.cs
Källa:
Math.cs
Källa:
Math.cs

Tillhandahåller konstanter och statiska metoder för trigonometriska, logaritmiska och andra vanliga matematiska funktioner.

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
Arv
Object
Math

Exempel

I följande exempel används flera matematiska och trigonometriska funktioner från Math klassen för att beräkna de inre vinklarna för en trapetsoid.

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

Fält

Name Description
E

Representerar den naturliga logaritmiska basen, som anges av konstanten , e.
PI

Representerar förhållandet mellan en cirkels omkrets och dess diameter, som anges av konstanten, π.
Tau

Representerar antalet radianer i en tur, som anges av konstanten, τ.

Metoder

Name Description
Abs(Decimal)

Returnerar det absoluta värdet för ett Decimal tal.
Abs(Double)

Returnerar det absoluta värdet för ett flyttal med dubbel precision.
Abs(Int16)

Returnerar det absoluta värdet för ett 16-bitars signerat heltal.
Abs(Int32)

Returnerar det absoluta värdet för ett 32-bitars signerat heltal.
Abs(Int64)

Returnerar det absoluta värdet för ett 64-bitars signerat heltal.
Abs(IntPtr)

Returnerar det absoluta värdet för ett inbyggt signerat heltal.
Abs(SByte)

Returnerar det absoluta värdet för ett 8-bitars signerat heltal.
Abs(Single)

Returnerar det absoluta värdet för ett flyttal med enkel precision.
Acos(Double)

Returnerar vinkeln vars cosiné är det angivna talet.
Acosh(Double)

Returnerar vinkeln vars hyperboliska cosiné är det angivna talet.
Asin(Double)

Returnerar vinkeln vars sinus är det angivna talet.
Asinh(Double)

Returnerar vinkeln vars hyperboliska sinus är det angivna talet.
Atan(Double)

Returnerar vinkeln vars tangent är det angivna talet.
Atan2(Double, Double)

Returnerar vinkeln vars tangent är kvoten för två angivna tal.
Atanh(Double)

Returnerar vinkeln vars hyperboliska tangens är det angivna talet.
BigMul(Int32, Int32)

Producerar hela produkten av två 32-bitarsnummer.
BigMul(Int64, Int64, Int64)

Producerar den fullständiga produkten av två 64-bitarsnummer.
BigMul(Int64, Int64)

Producerar den fullständiga produkten av två 64-bitarsnummer.
BigMul(UInt32, UInt32)

Ger den fullständiga produkten av två osignerade 32-bitarsnummer.
BigMul(UInt64, UInt64, UInt64)

Genererar den fullständiga produkten av två osignerade 64-bitarsnummer.
BigMul(UInt64, UInt64)

Genererar den fullständiga produkten av två osignerade 64-bitarsnummer.
BitDecrement(Double)

Returnerar det största värdet som jämför mindre än ett angivet värde.
BitIncrement(Double)

Returnerar det minsta värde som jämför större än ett angivet värde.
Cbrt(Double)

Returnerar kubroten för ett angivet tal.
Ceiling(Decimal)

Returnerar det minsta integralvärdet som är större än eller lika med det angivna decimaltalet.
Ceiling(Double)

Returnerar det minsta integralvärdet som är större än eller lika med det angivna flyttalsnumret med dubbel precision.
Clamp(Byte, Byte, Byte)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(Decimal, Decimal, Decimal)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(Double, Double, Double)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(Int16, Int16, Int16)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(Int32, Int32, Int32)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(Int64, Int64, Int64)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(IntPtr, IntPtr, IntPtr)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(SByte, SByte, SByte)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(Single, Single, Single)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(UInt16, UInt16, UInt16)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(UInt32, UInt32, UInt32)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(UInt64, UInt64, UInt64)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
Clamp(UIntPtr, UIntPtr, UIntPtr)

Returnerar value fastklämd till det inkluderande intervallet för min och max.
CopySign(Double, Double)

Returnerar ett värde med storleken x på och tecknet för y.
Cos(Double)

Returnerar cosininen för den angivna vinkeln.
Cosh(Double)

Returnerar den angivna vinkelns hyperboliska cosiné.
DivRem(Byte, Byte)

Genererar kvoten och resten av två osignerade 8-bitars tal.
DivRem(Int16, Int16)

Genererar kvoten och resten av två signerade 16-bitarsnummer.
DivRem(Int32, Int32, Int32)

Beräknar kvoten för två 32-bitars signerade heltal och returnerar även resten i en utdataparameter.
DivRem(Int32, Int32)

Genererar kvoten och resten av två signerade 32-bitarsnummer.
DivRem(Int64, Int64, Int64)

Beräknar kvoten för två 64-bitars signerade heltal och returnerar även resten i en utdataparameter.
DivRem(Int64, Int64)

Genererar kvoten och resten av två signerade 64-bitarsnummer.
DivRem(IntPtr, IntPtr)

Genererar kvoten och resten av två signerade interna tal.
DivRem(SByte, SByte)

Genererar kvoten och resten av två signerade 8-bitarsnummer.
DivRem(UInt16, UInt16)

Genererar kvoten och resten av två osignerade 16-bitars tal.
DivRem(UInt32, UInt32)

Genererar kvoten och resten av två osignerade 32-bitarsnummer.
DivRem(UInt64, UInt64)

Genererar kvoten och resten av två osignerade 64-bitarsnummer.
DivRem(UIntPtr, UIntPtr)

Genererar kvoten och resten av två osignerade interna tal.
Exp(Double)

Returnerar e upphöjt till den angivna kraften.
Floor(Decimal)

Returnerar det största integralvärdet mindre än eller lika med det angivna decimaltalet.
Floor(Double)

Returnerar det största integralvärdet mindre än eller lika med det angivna flyttalsnumret med dubbel precision.
FusedMultiplyAdd(Double, Double, Double)

Returnerar (x * y) + z, avrundat som en ternary-åtgärd.
IEEERemainder(Double, Double)

Returnerar resten från divisionen av ett angivet tal med ett annat angivet tal.
ILogB(Double)

Returnerar base 2-heltalsloggaritmen för ett angivet tal.
Log(Double, Double)

Returnerar logaritmen för ett angivet tal i en angiven bas.
Log(Double)

Returnerar logaritmen natural (base e) för ett angivet tal.
Log10(Double)

Returnerar bas 10 logaritm för ett angivet tal.
Log2(Double)

Returnerar bas 2-logaritmen för ett angivet tal.
Max(Byte, Byte)

Returnerar det större av två 8-bitars osignerade heltal.
Max(Decimal, Decimal)

Returnerar det större av två decimaltal.
Max(Double, Double)

Returnerar det större av två flyttal med dubbel precision.
Max(Int16, Int16)

Returnerar det större av två 16-bitars signerade heltal.
Max(Int32, Int32)

Returnerar det större av två 32-bitars signerade heltal.
Max(Int64, Int64)

Returnerar det större av två 64-bitars signerade heltal.
Max(IntPtr, IntPtr)

Returnerar det större av två inbyggda signerade heltal.
Max(SByte, SByte)

Returnerar det större av två 8-bitars signerade heltal.
Max(Single, Single)

Returnerar det större av två flyttalsnummer med enkel precision.
Max(UInt16, UInt16)

Returnerar det större av två 16-bitars osignerade heltal.
Max(UInt32, UInt32)

Returnerar det större av två 32-bitars osignerade heltal.
Max(UInt64, UInt64)

Returnerar det större av två 64-bitars osignerade heltal.
Max(UIntPtr, UIntPtr)

Returnerar det större av två inbyggda osignerade heltal.
MaxMagnitude(Double, Double)

Returnerar den större storleken på två flyttal med dubbel precision.
Min(Byte, Byte)

Returnerar det mindre av två 8-bitars osignerade heltal.
Min(Decimal, Decimal)

Returnerar det mindre av två decimaltal.
Min(Double, Double)

Returnerar det mindre av två flyttal med dubbel precision.
Min(Int16, Int16)

Returnerar det mindre av två 16-bitars signerade heltal.
Min(Int32, Int32)

Returnerar det mindre av två 32-bitars signerade heltal.
Min(Int64, Int64)

Returnerar det mindre av två 64-bitars signerade heltal.
Min(IntPtr, IntPtr)

Returnerar det mindre av två inbyggda signerade heltal.
Min(SByte, SByte)

Returnerar det mindre av två 8-bitars signerade heltal.
Min(Single, Single)

Returnerar det mindre av två flyttal med enkel precision.
Min(UInt16, UInt16)

Returnerar det mindre av två 16-bitars osignerade heltal.
Min(UInt32, UInt32)

Returnerar det mindre av två 32-bitars osignerade heltal.
Min(UInt64, UInt64)

Returnerar det mindre av två 64-bitars osignerade heltal.
Min(UIntPtr, UIntPtr)

Returnerar det mindre av två inbyggda osignerade heltal.
MinMagnitude(Double, Double)

Returnerar den mindre storleken på två flyttal med dubbel precision.
Pow(Double, Double)

Returnerar ett angivet tal som har upphöjts till den angivna kraften.
ReciprocalEstimate(Double)

Returnerar en uppskattning av reciprocal för ett angivet tal.
ReciprocalSqrtEstimate(Double)

Returnerar en uppskattning av den ömsesidiga kvadratroten för ett angivet tal.
Round(Decimal, Int32, MidpointRounding)

Avrundar ett decimalvärde till ett angivet antal bråksiffror med den angivna avrundningskonventionen.
Round(Decimal, Int32)

Avrundar ett decimalvärde till ett angivet antal bråksiffror och avrundar mittpunktsvärden till närmaste jämna tal.
Round(Decimal, MidpointRounding)

Avrundar ett decimalvärde som ett heltal med den angivna avrundningskonventionen.
Round(Decimal)

Avrundar ett decimalvärde till närmaste integralvärde och avrundar mittpunktsvärdena till närmaste jämna tal.
Round(Double, Int32, MidpointRounding)

Avrundar ett flyttal med dubbel precision till ett angivet antal bråksiffror med den angivna avrundningskonventionen.
Round(Double, Int32)

Avrundar ett flyttal med dubbel precision till ett angivet antal bråksiffror och avrundar mittpunktsvärden till närmaste jämna tal.
Round(Double, MidpointRounding)

Avrundar ett flyttal med dubbel precision till ett heltal med den angivna avrundningskonventionen.
Round(Double)

Avrundar ett flyttal med dubbel precision till närmaste integralvärde och avrundar mittpunktsvärdena till närmaste jämna tal.
ScaleB(Double, Int32)

Returnerar x * 2^n som beräknas effektivt.
Sign(Decimal)

Returnerar ett heltal som anger tecknet för ett decimaltal.
Sign(Double)

Returnerar ett heltal som anger tecknet för ett flyttal med dubbel precision.
Sign(Int16)

Returnerar ett heltal som anger tecknet för ett 16-bitars signerat heltal.
Sign(Int32)

Returnerar ett heltal som anger tecknet för ett 32-bitars signerat heltal.
Sign(Int64)

Returnerar ett heltal som anger tecknet för ett 64-bitars signerat heltal.
Sign(IntPtr)

Returnerar ett heltal som anger tecknet för ett inbyggt signerat heltal.
Sign(SByte)

Returnerar ett heltal som anger tecknet för ett 8-bitars signerat heltal.
Sign(Single)

Returnerar ett heltal som anger tecknet för ett flyttal med enkel precision.
Sin(Double)

Returnerar sinus för den angivna vinkeln.
SinCos(Double)

Returnerar sinus och cosinus för den angivna vinkeln.
Sinh(Double)

Returnerar den angivna vinkelns hyperboliska sinus.
Sqrt(Double)

Returnerar kvadratroten för ett angivet tal.
Tan(Double)

Returnerar tangensen för den angivna vinkeln.
Tanh(Double)

Returnerar den angivna vinkelns hyperboliska tangens.
Truncate(Decimal)

Beräknar den integrerade delen av ett angivet decimaltal.
Truncate(Double)

Beräknar den integrerade delen av ett angivet flyttal med dubbel precision.

Gäller för