RealFunctions

RealFunctions

public protocol RealFunctions: ElementaryFunctions

Inheritance

ElementaryFunctions

Requirements

atan2(y:​x:​)

atan(y/x), with sign selected according to the quadrant of (x, y).

static func atan2(y: Self, x: Self) -> Self

See also:

• atan()

erf(_:​)

The error function evaluated at x.

static func erf(_ x: Self) -> Self

See also:

• erfc()

erfc(_:​)

The complimentary error function evaluated at x.

static func erfc(_ x: Self) -> Self

See also:

• erf()

exp2(_:​)

2^x

static func exp2(_ x: Self) -> Self

See also:

• exp()

• expMinusOne()

• exp10()

• log2()

• pow()

exp10(_:​)

10^x

static func exp10(_ x: Self) -> Self

See also:

• exp()

• expMinusOne()

• exp2()

• log10()

• pow()

hypot(_:​_:​)

sqrt(x*x + y*y), computed in a manner that avoids spurious overflow or underflow.

static func hypot(_ x: Self, _ y: Self) -> Self

gamma(_:​)

The gamma function Γ(x).

static func gamma(_ x: Self) -> Self

See also:

• logGamma()

• signGamma()

log2(_:​)

The base-2 logarithm of x.

static func log2(_ x: Self) -> Self

See also:

• exp2()

• log()

• log(onePlus:)

• log10()

log10(_:​)

The base-10 logarithm of x.

static func log10(_ x: Self) -> Self

See also:

• exp10()

• log()

• log(onePlus:)

• log2()

logGamma(_:​)

!os(Windows)

The logarithm of the absolute value of the gamma function, log(|Γ(x)|).

static func logGamma(_ x: Self) -> Self

Not available on Windows targets.

See also:

• gamma()

• signGamma()

signGamma(_:​)

!os(Windows)

The sign of the gamma function, Γ(x).

static func signGamma(_ x: Self) -> FloatingPointSign

For x >= 0, signGamma(x) is .plus. For negative x, signGamma(x) is .plus when x is an integer, and otherwise it is .minus whenever trunc(x) is even, and .plus when trunc(x) is odd.

This function is used together with logGamma, which computes the logarithm of the absolute value of Γ(x), to recover the sign information.

Not available on Windows targets.

See also:

• gamma()

• logGamma()

_mulAdd(_:​_:​_:​)

a*b + c, computed either with an FMA or with separate multiply and add.

static func _mulAdd(_ a: Self, _ b: Self, _ c: Self) -> Self

Whichever is faster should be chosen by the compiler statically.