vForce

reciprocal

static reciprocalResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func reciprocal<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the reciprocal of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

reciprocal

static reciprocalResult58720(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func reciprocal<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the reciprocal of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

reciprocal

static reciprocal(vector: Array<number>): Array<number>

static func reciprocal<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the reciprocal of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

reciprocal

static reciprocal13158(vector: Array<number>): Array<number>

static func reciprocal<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the reciprocal of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

nearestInteger

static nearestIntegerResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func nearestInteger<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the nearest integer to each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

nearestInteger

static nearestIntegerResult30523(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func nearestInteger<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the nearest integer to each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

nearestInteger

static nearestInteger(vector: Array<number>): Array<number>

static func nearestInteger<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the nearest integer to each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

nearestInteger

static nearestInteger57654(vector: Array<number>): Array<number>

static func nearestInteger<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the nearest integer to each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

truncatingRemainder

static truncatingRemainderDividendsDivisorsResult(dividends: Array<number>, divisors: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func truncatingRemainder<T, U, V>(dividends: T, divisors: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Double, U.Element == Double, V.Element == Double

Calculates the remainder of the elements in `dividends` divided by the the elements in `divisors` using truncating division; single-precision. - Parameter dividends: Input dividends. - Parameter divisors: Input divisors. - Parameter result: Output values. For each corresponding `a` from `dividends` and `b` from `divisors`, the result `r` satisfies: a = bq + r where q is the integer formed by rounding `a/b` towards zero, so `abs(r) < abs(b)` and `r` has the same sign as `a`.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

truncatingRemainder

static truncatingRemainderDividendsDivisorsResult10690(dividends: Array<number>, divisors: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func truncatingRemainder<T, U, V>(dividends: T, divisors: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Float, U.Element == Float, V.Element == Float

Calculates the remainder of the elements in `dividends` divided by the the elements in `divisors` using truncating division; single-precision. - Parameter dividends: Input dividends. - Parameter divisors: Input divisors. - Parameter result: Output values. For each corresponding `a` from `dividends` and `b` from `divisors`, the result `r` satisfies: a = bq + r where q is the integer formed by rounding `a/b` towards zero, so `abs(r) < abs(b)` and `r` has the same sign as `a`.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

truncatingRemainder

static truncatingRemainderDividendsDivisors(dividends: Array<number>, divisors: Array<number>): Array<number>

static func truncatingRemainder<U, V>(dividends: U, divisors: V) -> [Double] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Returns the remainder of the elements in `dividends` divided by the the elements in `divisors` using truncating division; double-precision. - Parameter dividends: Input dividends. - Parameter divisors: Input divisors. - Returns: Output values. For each corresponding `a` from `dividends` and `b` from `divisors`, the result `r` satisfies: a = bq + r where q is the integer formed by rounding `a/b` towards zero, so `abs(r) < abs(b)` and `r` has the same sign as `a`.

truncatingRemainder

static truncatingRemainderDividendsDivisors47109(dividends: Array<number>, divisors: Array<number>): Array<number>

static func truncatingRemainder<U, V>(dividends: U, divisors: V) -> [Float] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Returns the remainder of the elements in `dividends` divided by the the elements in `divisors` using truncating division; single-precision. - Parameter dividends: Input dividends. - Parameter divisors: Input divisors. - Returns: Output values. For each corresponding `a` from `dividends` and `b` from `divisors`, the result `r` satisfies: a = bq + r where q is the integer formed by rounding `a/b` towards zero, so `abs(r) < abs(b)` and `r` has the same sign as `a`.

cos

static cosResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func cos<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the cosine of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

cos

static cosResult7229(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func cos<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the cosine of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

cos

static cos(vector: Array<number>): Array<number>

static func cos<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the cosine of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

cos

static cos49877(vector: Array<number>): Array<number>

static func cos<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the cosine of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

exp

static expResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func exp<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates e raised to the power of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

exp

static expResult11289(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func exp<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates e raised to the power of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

exp

static exp(vector: Array<number>): Array<number>

static func exp<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns e raised to the power of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

exp

static exp55713(vector: Array<number>): Array<number>

static func exp<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns e raised to the power of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

log

static logResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func log<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the natural logarithm of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

log

static logResult80132(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func log<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the natural logarithm of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

log

static log(vector: Array<number>): Array<number>

static func log<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the natural logarithm of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

log

static log48634(vector: Array<number>): Array<number>

static func log<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the natural logarithm of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

pow

static powBasesExponentsResult(bases: Array<number>, exponents: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func pow<T, U, V>(bases: T, exponents: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Double, U.Element == Double, V.Element == Double

Calculates each element in `bases` rasied to the power of the corresponding element in `exponents`, writing the result to `result`, double-precision. - Parameter bases: Input base values. - Parameter exponents: Input exponents. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

pow

static powBasesExponentsResult71658(bases: Array<number>, exponents: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func pow<T, U, V>(bases: T, exponents: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Float, U.Element == Float, V.Element == Float

Calculates each element in `bases` rasied to the power of the corresponding element in `exponents`, writing the result to `result`, single-precision. - Parameter bases: Input base values. - Parameter exponents: Input exponents. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

pow

static powBasesExponents(bases: Array<number>, exponents: Array<number>): Array<number>

static func pow<U, V>(bases: U, exponents: V) -> [Double] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Returns each element in `bases` rasied to the power of the corresponding element in `exponents`, double-precision. - Parameter bases: Input base values. - Parameter exponents: Input exponents. - Returns: Output values.

pow

static powBasesExponents36481(bases: Array<number>, exponents: Array<number>): Array<number>

static func pow<U, V>(bases: U, exponents: V) -> [Float] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Returns each element in `bases` rasied to the power of the corresponding element in `exponents`, single-precision. - Parameter bases: Input base values. - Parameter exponents: Input exponents. - Returns: Output values.

sin

static sinResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func sin<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the sine of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

sin

static sinResult1584(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func sin<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the sine of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

sin

static sin(vector: Array<number>): Array<number>

static func sin<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the sine of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

sin

static sin4374(vector: Array<number>): Array<number>

static func sin<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the sine of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

tan

static tanResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func tan<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the tangent of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

tan

static tanResult77129(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func tan<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the tangent of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

tan

static tan(vector: Array<number>): Array<number>

static func tan<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the tangent of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

tan

static tan51057(vector: Array<number>): Array<number>

static func tan<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the tangent of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

acos

static acosResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func acos<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the arccosine of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

acos

static acosResult80779(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func acos<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the arccosine of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

acos

static acos(vector: Array<number>): Array<number>

static func acos<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the arccosine of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

acos

static acos70859(vector: Array<number>): Array<number>

static func acos<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the arccosine of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

asin

static asinResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func asin<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the arcsine of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

asin

static asinResult3698(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func asin<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the arcsine of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

asin

static asin(vector: Array<number>): Array<number>

static func asin<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the arcsine of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

asin

static asin47896(vector: Array<number>): Array<number>

static func asin<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the arcsine of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

atan

static atanResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func atan<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the arctangent of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

atan

static atanResult47463(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func atan<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the arctangent of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

atan

static atan(vector: Array<number>): Array<number>

static func atan<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the arctangent of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

atan

static atan85575(vector: Array<number>): Array<number>

static func atan<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the arctangent of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

ceil

static ceilResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func ceil<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the ceiling of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

ceil

static ceilResult55428(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func ceil<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the ceiling of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

ceil

static ceil(vector: Array<number>): Array<number>

static func ceil<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the ceiling of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

ceil

static ceil69274(vector: Array<number>): Array<number>

static func ceil<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the ceiling of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

cosh

static coshResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func cosh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the hyperbolic cosine of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

cosh

static coshResult9764(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func cosh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the hyperbolic cosine of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

cosh

static cosh(vector: Array<number>): Array<number>

static func cosh<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the hyperbolic cosine of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

cosh

static cosh58426(vector: Array<number>): Array<number>

static func cosh<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the hyperbolic cosine of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

exp2

static exp2Result(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func exp2<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates 2 raised to the power of each element minus one in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

exp2

static exp2Result42362(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func exp2<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates 2 raised to the power of each element minus one in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

exp2

static exp2(vector: Array<number>): Array<number>

static func exp2<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns 2 raised to the power of each element minus one in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

exp2

static exp289648(vector: Array<number>): Array<number>

static func exp2<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns 2 raised to the power of each element minus one in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

log2

static log2Result(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func log2<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the base two logarithm of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

log2

static log2Result29281(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func log2<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the base two logarithm of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

log2

static log2(vector: Array<number>): Array<number>

static func log2<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the base two logarithm of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

log2

static log22329(vector: Array<number>): Array<number>

static func log2<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the base two logarithm of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

logb

static logbResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func logb<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the unbiased exponent of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values. This function calculates `floor(log2(vector))`.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

logb

static logbResult69489(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func logb<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the unbiased exponent of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values. This function calculates `floor(log2(vector))`.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

logb

static logb(vector: Array<number>): Array<number>

static func logb<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the unbiased exponent of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

logb

static logb91817(vector: Array<number>): Array<number>

static func logb<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the unbiased exponent of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

sinh

static sinhResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func sinh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the hyperbolic sine of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

sinh

static sinhResult94663(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func sinh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the hyperbolic sine of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

sinh

static sinh(vector: Array<number>): Array<number>

static func sinh<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the hyperbolic sine of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

sinh

static sinh25159(vector: Array<number>): Array<number>

static func sinh<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the hyperbolic sine of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

sqrt

static sqrtResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func sqrt<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the square root of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

sqrt

static sqrtResult9199(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func sqrt<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the square root of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

sqrt

static sqrt(vector: Array<number>): Array<number>

static func sqrt<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the square root of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

sqrt

static sqrt50335(vector: Array<number>): Array<number>

static func sqrt<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the square root of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

tanh

static tanhResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func tanh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the hyperbolic tangent of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

tanh

static tanhResult82700(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func tanh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the hyperbolic tangent of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

tanh

static tanh(vector: Array<number>): Array<number>

static func tanh<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the hyperbolic tangent of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

tanh

static tanh67602(vector: Array<number>): Array<number>

static func tanh<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the hyperbolic tangent of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

acosh

static acoshResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func acosh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the inverse hyperbolic cosine of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

acosh

static acoshResult47206(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func acosh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the inverse hyperbolic cosine of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

acosh

static acosh(vector: Array<number>): Array<number>

static func acosh<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the inverse hyperbolic cosine of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

acosh

static acosh51948(vector: Array<number>): Array<number>

static func acosh<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the inverse hyperbolic cosine of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

asinh

static asinhResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func asinh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the inverse hyperbolic sine of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

asinh

static asinhResult9925(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func asinh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the inverse hyperbolic sine of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

asinh

static asinh(vector: Array<number>): Array<number>

static func asinh<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the inverse hyperbolic sine of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

asinh

static asinh27341(vector: Array<number>): Array<number>

static func asinh<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the inverse hyperbolic sine of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

atan2

static atan2XYResult(x: Array<number>, y: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func atan2<T, U, V>(x: T, y: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Double, U.Element == Double, V.Element == Double

Calculates the arctangent of each pair of elements in two arrays of double-precision values. - Parameter x: The input array, _x_. - Parameter y: The input array, _y_. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

atan2

static atan2XYResult83713(x: Array<number>, y: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func atan2<T, U, V>(x: T, y: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Float, U.Element == Float, V.Element == Float

Calculates the arctangent of each pair of elements in two arrays of single-precision values. - Parameter x: The input array, _x_. - Parameter y: The input array, _y_. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

atan2

static atan2XY(x: Array<number>, y: Array<number>): Array<number>

static func atan2<U, V>(x: U, y: V) -> [Double] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Returns the arctangent of each pair of elements in two arrays of double-precision values. - Parameter x: The input array, _x_. - Parameter y: The input array, _y_. - Returns: Output values.

atan2

static atan2XY16462(x: Array<number>, y: Array<number>): Array<number>

static func atan2<U, V>(x: U, y: V) -> [Float] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Returns the arctangent of each pair of elements in two arrays of single-precision values. - Parameter x: The input array, _x_. - Parameter y: The input array, _y_. - Returns: Output values.

atanh

static atanhResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func atanh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the inverse hyperbolic tangent of each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

atanh

static atanhResult3438(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func atanh<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the inverse hyperbolic tangent of each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

atanh

static atanh(vector: Array<number>): Array<number>

static func atanh<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the inverse hyperbolic tangent of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

atanh

static atanh31204(vector: Array<number>): Array<number>

static func atanh<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the inverse hyperbolic tangent of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

cosPi

static cosPiResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func cosPi<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the cosine of pi multiplied by each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

cosPi

static cosPiResult99587(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func cosPi<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the cosine of pi multiplied by each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

cosPi

static cosPi(vector: Array<number>): Array<number>

static func cosPi<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the cosine of pi multiplied of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

cosPi

static cosPi92558(vector: Array<number>): Array<number>

static func cosPi<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the cosine of pi multiplied of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

expm1

static expm1Result(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func expm1<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates e raised to the power of each element minus one in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

expm1

static expm1Result16589(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func expm1<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates e raised to the power of each element minus one in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

expm1

static expm1(vector: Array<number>): Array<number>

static func expm1<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns e raised to the power of each element minus one in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

expm1

static expm124325(vector: Array<number>): Array<number>

static func expm1<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns e raised to the power of each element minus one in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

floor

static floorResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func floor<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the floor of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

floor

static floorResult50450(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func floor<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the floor of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

floor

static floor(vector: Array<number>): Array<number>

static func floor<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the floor of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

floor

static floor33432(vector: Array<number>): Array<number>

static func floor<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the floor of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

log10

static log10Result(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func log10<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the ten logarithm of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

log10

static log10Result51987(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func log10<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the base ten logarithm of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

log10

static log10(vector: Array<number>): Array<number>

static func log10<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the base ten logarithm of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

log10

static log1051459(vector: Array<number>): Array<number>

static func log10<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the base ten logarithm of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

log1p

static log1pResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func log1p<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates `log(1+x)` of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

log1p

static log1pResult45235(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func log1p<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates `log(1+x)` of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

log1p

static log1p(vector: Array<number>): Array<number>

static func log1p<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns `log(1+x)` of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

log1p

static log1p33603(vector: Array<number>): Array<number>

static func log1p<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns `log(1+x)` of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

rsqrt

static rsqrtResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func rsqrt<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the reciprocal square root of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

rsqrt

static rsqrtResult17464(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func rsqrt<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the reciprocal square root of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

rsqrt

static rsqrt(vector: Array<number>): Array<number>

static func rsqrt<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the reciprocal square root of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

rsqrt

static rsqrt94190(vector: Array<number>): Array<number>

static func rsqrt<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the reciprocal square root of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

sinPi

static sinPiResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func sinPi<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the sine of pi multiplied by each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

sinPi

static sinPiResult16358(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func sinPi<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the sine of pi multiplied by each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

sinPi

static sinPi(vector: Array<number>): Array<number>

static func sinPi<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the sine of pi multiplied of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

sinPi

static sinPi1333(vector: Array<number>): Array<number>

static func sinPi<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the sine of pi multiplied of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

tanPi

static tanPiResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func tanPi<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the tangent of pi multiplied by each element in `vector`, writing the result to `result`, double-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

tanPi

static tanPiResult99391(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func tanPi<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the tangent of pi multiplied by each element in `vector`, writing the result to `result`, single-precision. - Parameter vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

tanPi

static tanPi(vector: Array<number>): Array<number>

static func tanPi<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the tangent of pi multiplied of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

tanPi

static tanPi15610(vector: Array<number>): Array<number>

static func tanPi<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the tangent of pi multiplied of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

trunc

static truncResult(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func trunc<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Calculates the integer truncation of each element in `vector`, writing the result to `result`, double-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

trunc

static truncResult80990(vector: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func trunc<U, V>(_ vector: U, result: inout V) where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Calculates the integer truncation of each element in `vector`, writing the result to `result`, single-precision. - Parameter _ vector: Input values. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

trunc

static trunc(vector: Array<number>): Array<number>

static func trunc<U>(_ vector: U) -> [Double] where U : AccelerateBuffer, U.Element == Double

Returns the integer truncation of each element in `vector`, double-precision. - Parameter _ vector: Input values. - Returns: Output values.

trunc

static trunc53620(vector: Array<number>): Array<number>

static func trunc<U>(_ vector: U) -> [Float] where U : AccelerateBuffer, U.Element == Float

Returns the integer truncation of each element in `vector`, single-precision. - Parameter _ vector: Input values. - Returns: Output values.

sincos

static sincosSinResultCosResult(vector: Array<number>, sinResult: Array<number>, cosResult: Array<number>): { $ret: null; $out: { "sinResult": Array<number>; "cosResult": Array<number> } }

static func sincos<T, U, V>(_ vector: T, sinResult: inout U, cosResult: inout V) where T : AccelerateBuffer, U : AccelerateMutableBuffer, V : AccelerateMutableBuffer, T.Element == Double, U.Element == Double, V.Element == Double

Calculates the sine and cosine of each element in `vector`, writing the results to `sinresult` and `cosresult` respectively, double-precision. - Parameter vector: Input values. - Parameter sinresult: Output sine values. - Parameter cosresult: Output cosine values.

Omit the output parameters from the call. The result contains $ret and $out, with sinResult, cosResult inside $out.

sincos

static sincosSinResultCosResult96471(vector: Array<number>, sinResult: Array<number>, cosResult: Array<number>): { $ret: null; $out: { "sinResult": Array<number>; "cosResult": Array<number> } }

static func sincos<T, U, V>(_ vector: T, sinResult: inout U, cosResult: inout V) where T : AccelerateBuffer, U : AccelerateMutableBuffer, V : AccelerateMutableBuffer, T.Element == Float, U.Element == Float, V.Element == Float

Calculates the sine and cosine of each element in `vector`, writing the results to `sinresult` and `cosresult` respectively, single-precision. - Parameter vector: Input values. - Parameter sinresult: Output sine values. - Parameter cosresult: Output cosine values.

Omit the output parameters from the call. The result contains $ret and $out, with sinResult, cosResult inside $out.

copysign

static copysignMagnitudesSignsResult(magnitudes: Array<number>, signs: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func copysign<T, U, V>(magnitudes: T, signs: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Double, U.Element == Double, V.Element == Double

Copies the sign of each element in `signs` to the corresponding element in `magnitudes`, writing the result to `result`, double-precision. - Parameter magnitudes: Input magnitudes. - Parameter signs: Input signs. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

copysign

static copysignMagnitudesSignsResult88916(magnitudes: Array<number>, signs: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func copysign<T, U, V>(magnitudes: T, signs: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Float, U.Element == Float, V.Element == Float

Copies the sign of each element in `signs` to the corresponding element in `magnitudes`, writing the result to `result`, single-precision. - Parameter magnitudes: Input magnitudes. - Parameter signs: Input signs. - Parameter result: Output values.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

copysign

static copysignMagnitudesSigns(magnitudes: Array<number>, signs: Array<number>): Array<number>

static func copysign<U, V>(magnitudes: U, signs: V) -> [Double] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Returns the sign of each element in `signs` to the corresponding element in `magnitudes`, double-precision. - Parameter magnitudes: Input magnitudes. - Parameter signs: Input signs. - Returns: Output values.

copysign

static copysignMagnitudesSigns33843(magnitudes: Array<number>, signs: Array<number>): Array<number>

static func copysign<U, V>(magnitudes: U, signs: V) -> [Float] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Returns the sign of each element in `signs` to the corresponding element in `magnitudes`, single-precision. - Parameter magnitudes: Input magnitudes. - Parameter signs: Input signs. - Returns: Output values.

remainder

static remainderDividendsDivisorsResult(dividends: Array<number>, divisors: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func remainder<T, U, V>(dividends: T, divisors: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Double, U.Element == Double, V.Element == Double

Calculates the remainder after dividing each element in `dividends` by the corresponding element in `divisors`, double-precision. - Parameter dividends: Input dividends. - Parameter divisors: Input divisors. - Parameter result: Output values. For each corresponding `a` from `dividends` and `b` from `divisors`, the result `r` satisfies: a = bq + r where q is `a/b` rounded to the nearest integer, so `abs(r) <= abs(b/2)`.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

remainder

static remainderDividendsDivisorsResult43487(dividends: Array<number>, divisors: Array<number>, result: Array<number>): { $ret: null; $out: { "result": Array<number> } }

static func remainder<T, U, V>(dividends: T, divisors: U, result: inout V) where T : AccelerateBuffer, U : AccelerateBuffer, V : AccelerateMutableBuffer, T.Element == Float, U.Element == Float, V.Element == Float

Calculates the remainder after dividing each element in `dividends` by the corresponding element in `divisors`, single-precision. - Parameter dividends: Input dividends. - Parameter divisors: Input divisors. - Parameter result: Output values. For each corresponding `a` from `dividends` and `b` from `divisors`, the result `r` satisfies: a = bq + r where q is `a/b` rounded to the nearest integer, so `abs(r) <= abs(b/2)`.

Omit the output parameters from the call. The result contains $ret and $out, with result inside $out.

remainder

static remainderDividendsDivisors(dividends: Array<number>, divisors: Array<number>): Array<number>

static func remainder<U, V>(dividends: U, divisors: V) -> [Double] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Double, V.Element == Double

Returns the remainder after dividing each element in `dividends` by the corresponding element in `divisors`, double-precision. - Parameter dividends: Input dividends. - Parameter divisors: Input divisors. - Returns: Output values. For each corresponding `a` from `dividends` and `b` from `divisors`, the result `r` satisfies: a = bq + r where q is `a/b` rounded to the nearest integer, so `abs(r) <= abs(b/2)`.

remainder

static remainderDividendsDivisors12412(dividends: Array<number>, divisors: Array<number>): Array<number>

static func remainder<U, V>(dividends: U, divisors: V) -> [Float] where U : AccelerateBuffer, V : AccelerateMutableBuffer, U.Element == Float, V.Element == Float

Returns the remainder after dividing each element in `dividends` by the corresponding element in `divisors`, single-precision. - Parameter dividends: Input dividends. - Parameter divisors: Input divisors. - Returns: Output values. For each corresponding `a` from `dividends` and `b` from `divisors`, the result `r` satisfies: a = bq + r where q is `a/b` rounded to the nearest integer, so `abs(r) <= abs(b/2)`.