Dynamics Community Forum Thread Details

Hi, you can check codeunit 710 Math.
// ------------------------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// ------------------------------------------------------------------------------------------------

/// 
/// Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.
/// 
codeunit 710 Math
{
    Access = Public;

    var
        DotNetMath: DotNet Math;

    /// 
    /// Returns the value of pi.
    /// 
    /// Value of pi.
    procedure Pi(): Decimal
    begin
        exit(3.1415926535897931);
    end;

    /// 
    /// Returns the value of E.
    /// 
    /// Value of E.
    procedure E(): Decimal
    begin
        exit(2.7182818284590451);
    end;

    /// 
    /// Returns the absolute value of a Decimal number.
    /// 
    /// A decimal.
    /// A decimal number, x, such that 0 ≤ x ≤MaxValue
    procedure Abs(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Abs(decimalValue));
    end;

    /// 
    /// Returns the angle whose cosine is the specified number.
    /// 
    /// A number representing a cosine.
    /// An angle, θ, measured in radians, such that 0 ≤θ≤π
    procedure Acos(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Acos(decimalValue));
    end;

    /// 
    /// Returns the angle whose sine is the specified number.
    /// 
    /// A number representing a sine, where decimalValue must be greater than or equal to -1, but less than or equal to 1.
    /// An angle, θ, measured in radians, such that -π/2 ≤θ≤π/2
    procedure Asin(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Asin(decimalValue));
    end;

    /// 
    /// Returns the angle whose tangent is the specified number.
    /// 
    /// A number representing a tangent.
    /// An angle, θ, measured in radians, such that -π/2 ≤θ≤π/2.
    procedure Atan(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Atan(decimalValue));
    end;

    /// 
    /// Returns the angle whose tangent is the quotient of two specified numbers.
    /// 
    /// The y coordinate of a point.
    /// The x coordinate of a point.
    /// An angle, θ, measured in radians, such that -π≤θ≤π, and tan(θ) = y / x, where (x, y) is a point in the Cartesian plane. 
    procedure Atan2(y: Decimal; x: Decimal): Decimal
    begin
        exit(DotNetMath.Atan2(y, x));
    end;

    /// 
    /// Produces the full product of two 32-bit numbers.
    /// 
    /// The first number to multiply.
    /// The second number to multiply.
    /// The number containing the product of the specified numbers.
    procedure BigMul(a: Integer; b: Integer): BigInteger
    begin
        exit(DotNetMath.BigMul(a, b));
    end;

    /// 
    /// Returns the smallest integral value that is greater than or equal to the specified decimal number.
    /// 
    /// A decimal number.
    /// The smallest integral value that is greater than or equal to decimalValue.
    procedure Ceiling(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Ceiling(decimalValue));
    end;

    /// 
    /// Returns the cosine of the specified angle.
    /// 
    /// An angle, measured in radians.
    /// The cosine of decimalValue. 
    procedure Cos(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Cos(decimalValue));
    end;

    /// 
    /// Returns the hyperbolic cosine of the specified angle.
    /// 
    /// An angle, measured in radians.
    /// The hyperbolic cosine of value.
    procedure Cosh(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Cosh(decimalValue));
    end;

    /// 
    /// Returns e raised to the specified power.
    /// 
    /// A number specifying a power.
    /// The number e raised to the power decimalValue.
    procedure Exp(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Exp(decimalValue));
    end;

    /// 
    /// Returns the largest integral value less than or equal to the specified decimal number.
    /// 
    /// A decimal number.
    /// The largest integral value less than or equal to decimalValue.
    procedure Floor(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Floor(decimalValue));
    end;

    /// 
    /// Returns the remainder resulting from the division of a specified number by another specified number.
    /// 
    /// A dividend.
    /// A divisor.
    /// A number equal to x - (y Q), where Q is the quotient of x / y rounded to the nearest integer (if x / y falls halfway between two integers, the even integer is returned).
    procedure IEEERemainder(x: Decimal; y: Decimal): Decimal
    begin
        exit(DotNetMath.IEEERemainder(x, y));
    end;

    /// 
    /// Returns the natural (base e) logarithm of a specified number.
    /// 
    /// The number whose logarithm is to be found.
    /// The natural logarithm of decimalValue; that is, ln decimalValue, or log e decimalValue
    procedure Log(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Log(decimalValue));
    end;

    /// 
    /// Returns the logarithm of a specified number in a specified base.
    /// 
    /// The number whose logarithm is to be found.
    /// The base of the logarithm.
    /// The logarithm of a specified number in a specified base.
    procedure Log(a: Decimal; newBase: Decimal): Decimal
    begin
        exit(DotNetMath.Log(a, newBase));
    end;


    /// 
    /// Returns the base 10 logarithm of a specified number.
    /// 
    /// A number whose logarithm is to be found.
    /// The base 10 logarithm of the specified number
    procedure Log10(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Log10(decimalValue));
    end;

    /// 
    /// Returns the larger of two decimal numbers.
    /// 
    /// The first of two decimal numbers to compare.
    /// The second of two decimal numbers to compare.
    /// Parameter decimalValue1 or decimalValue2, whichever is larger.
    procedure "Max"(decimalValue1: Decimal; decimalValue2: Decimal): Decimal
    begin
        exit(DotNetMath.Max(decimalValue1, decimalValue2));
    end;

    /// 
    /// Returns the smaller of two decimal numbers.
    /// 
    /// The first of two decimal numbers to compare.
    /// The second of two decimal numbers to compare.
    /// Parameter decimalValue1 or decimalValue2, whichever is smaller.
    procedure "Min"(decimalValue1: Decimal; decimalValue2: Decimal): Decimal
    begin
        exit(DotNetMath.Min(decimalValue1, decimalValue2));
    end;

    /// 
    /// Returns a specified number raised to the specified power.
    /// 
    /// A double-precision floating-point number to be raised to a power.
    /// A double-precision floating-point number that specifies a power.
    /// The number x raised to the power y.
    procedure Pow(x: Decimal; y: Decimal): Decimal
    begin
        exit(DotNetMath.Pow(x, y));
    end;

    /// 
    /// Returns an integer that indicates the sign of a decimal number.
    /// 
    /// A signed decimal number.
    /// A number that indicates the sign of value.
    procedure Sign(decimalValue: Decimal): Integer
    begin
        exit(DotNetMath.Sign(decimalValue));
    end;

    /// 
    /// Returns the hyperbolic sine of the specified angle.
    /// 
    /// An angle, measured in radians.
    /// The hyperbolic sine of value.
    procedure Sinh(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Sinh(decimalValue));
    end;

    /// 
    /// Returns the sine of the specified angle.
    /// 
    /// An angle, measured in radians.
    /// The sine of a.
    procedure Sin(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Sin(decimalValue));
    end;

    /// 
    /// Returns the square root of a specified number.
    /// 
    /// The number whose square root is to be found.
    /// The positive square root of decimalValue.
    procedure Sqrt(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Sqrt(decimalValue));
    end;

    /// 
    /// Returns the tangent of the specified angle.
    /// 
    /// An angle, measured in radians.
    /// The tangent of a.
    procedure Tan(a: Decimal): Decimal
    begin
        exit(DotNetMath.Tan(a));
    end;

    /// 
    /// Returns the hyperbolic tangent of the specified angle.
    /// 
    /// An angle, measured in radians.
    /// The hyperbolic tangent of value.
    procedure Tanh(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Tanh(decimalValue));
    end;

    /// 
    /// Calculates the integral part of a specified decimal number.
    /// 
    /// A number to truncate.
    /// The integral part of decimalValue.
    procedure Truncate(decimalValue: Decimal): Decimal
    begin
        exit(DotNetMath.Truncate(decimalValue));
    end;
}
Hope this helps.
Thanks.
ZHU
Community site session details

Custom Calculation in Business Central

Helpful resources

News and Announcements

Quick Links

🌸 Community Spring Festival 2025 Challenge 🌸

Jonas ”Jones” Melgaard – Community Spotlight

Kudos to the March Top 10 Community Stars!

Leaderboard

Featured topics

Product updates

Community site session details

Custom Calculation in Business Central

Helpful resources

News and Announcements

Quick Links

🌸 Community Spring Festival 2025 Challenge 🌸

Jonas ”Jones” Melgaard – Community Spotlight

Kudos to the March Top 10 Community Stars!

Subscribe to this forum!

Select categories

Leaderboard

Featured topics

Product updates
