
acosh(X::Array{Float32}) = Vectorize.Accelerate.acosh(X)

sub!(X::Array{Float64}, Y::Array{Float64}, Z::Array{Float64}) = Vectorize.Accelerate.sub!(X, Y, Z)

atanh(X::Array{Float32}) = Vectorize.Accelerate.atanh(X)

round(X::Array{Float32}) = Vectorize.Accelerate.round(X)

sinpi(X::Array{Float32}) = Vectorize.Accelerate.sinpi(X)

acos!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.acos!(X, Y)

log(X::Array{Float32}) = Vectorize.Accelerate.log(X)

log!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.log!(X, Y)

log2!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.log2!(X, Y)

sub(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.sub(X, Y)

expm1(X::Array{Float64}) = Vectorize.Accelerate.expm1(X)

mul(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.mul(X, Y)

atan!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.atan!(X, Y)

sqrt!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.sqrt!(X, Y)

exp!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.exp!(X, Y)

max!(X::Array{Float32}, Y::Array{Float32}, Z::Array{Float32}) = Vectorize.Accelerate.max!(X, Y, Z)

log2(X::Array{Float64}) = Vectorize.Accelerate.log2(X)

abs!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.abs!(X, Y)

sinpi!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.sinpi!(X, Y)

asin!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.asin!(X, Y)

rec(X::Array{Float64}) = Vectorize.Accelerate.rec(X)

sqrt(X::Array{Float64}) = Vectorize.Accelerate.sqrt(X)

div(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.div(X, Y)

log2(X::Array{Float32}) = Vectorize.Accelerate.log2(X)

asinh(X::Array{Float32}) = Vectorize.Accelerate.asinh(X)

tanpi!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.tanpi!(X, Y)

floor(X::Array{Float32}) = Vectorize.Accelerate.floor(X)

exp2(X::Array{Float64}) = Vectorize.Accelerate.exp2(X)

expm1(X::Array{Float32}) = Vectorize.Accelerate.expm1(X)

cosh(X::Array{Float32}) = Vectorize.Accelerate.cosh(X)

sub(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.sub(X, Y)

asin(X::Array{Float64}) = Vectorize.Accelerate.asin(X)

rec!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.rec!(X, Y)

log1p(X::Array{Float32}) = Vectorize.Accelerate.log1p(X)

floor(X::Array{Float64}) = Vectorize.Accelerate.floor(X)

invsqrt!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.invsqrt!(X, Y)

min!(X::Array{Float64}, Y::Array{Float64}, Z::Array{Float64}) = Vectorize.Accelerate.min!(X, Y, Z)

min(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.min(X, Y)

div!(X::Array{Float64}, Y::Array{Float64}, Z::Array{Float64}) = Vectorize.Accelerate.div!(X, Y, Z)

cos(X::Array{Float64}) = Vectorize.Accelerate.cos(X)

cospi(X::Array{Float32}) = Vectorize.Accelerate.cospi(X)

round!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.round!(X, Y)

mean(X::Array{Float64}) = Vectorize.Accelerate.mean(X)

rec!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.rec!(X, Y)

sqrt!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.sqrt!(X, Y)

summag(X::Array{Float32}) = Vectorize.Accelerate.summag(X)

add(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.add(X, Y)

sum(X::Array{Float64}) = Vectorize.Accelerate.sum(X)

exp!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.exp!(X, Y)

ceil(X::Array{Float64}) = Vectorize.Accelerate.ceil(X)

ceil!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.ceil!(X, Y)

trunc!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.trunc!(X, Y)

ceil(X::Array{Float32}) = Vectorize.Accelerate.ceil(X)

asinh!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.asinh!(X, Y)

exponent(X::Array{Float32}) = Vectorize.Accelerate.exponent(X)

cosh!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.cosh!(X, Y)

asinh(X::Array{Float64}) = Vectorize.Accelerate.asinh(X)

abs!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.abs!(X, Y)

exponent!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.exponent!(X, Y)

log1p!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.log1p!(X, Y)

acos!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.acos!(X, Y)

cospi!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.cospi!(X, Y)

cospi(X::Array{Float64}) = Vectorize.Accelerate.cospi(X)

add!(X::Array{Float32}, Y::Array{Float32}, Z::Array{Float32}) = Vectorize.Accelerate.add!(X, Y, Z)

exp2(X::Array{Float32}) = Vectorize.Accelerate.exp2(X)

acos(X::Array{Float64}) = Vectorize.Accelerate.acos(X)

asin!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.asin!(X, Y)

log10(X::Array{Float32}) = Vectorize.Accelerate.log10(X)

sum(X::Array{Float32}) = Vectorize.Accelerate.sum(X)

minimum(X::Array{Float32}) = Vectorize.Accelerate.minimum(X)

log10!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.log10!(X, Y)

trunc(X::Array{Float32}) = Vectorize.Accelerate.trunc(X)

log!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.log!(X, Y)

invsqrt(X::Array{Float32}) = Vectorize.Accelerate.invsqrt(X)

atan(X::Array{Float64}) = Vectorize.Accelerate.atan(X)

sinh!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.sinh!(X, Y)

sqrt(X::Array{Float32}) = Vectorize.Accelerate.sqrt(X)

tanpi!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.tanpi!(X, Y)

abs(X::Array{Float64}) = Vectorize.Accelerate.abs(X)

atan!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.atan!(X, Y)

invsqrt!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.invsqrt!(X, Y)

log10!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.log10!(X, Y)

atanh!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.atanh!(X, Y)

atanh(X::Array{Float64}) = Vectorize.Accelerate.atanh(X)

sinpi(X::Array{Float64}) = Vectorize.Accelerate.sinpi(X)

cospi!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.cospi!(X, Y)

tan!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Yeppp.tan!(X, Y)

rec(X::Array{Float32}) = Vectorize.Accelerate.rec(X)

log(X::Array{Float64}) = Vectorize.Accelerate.log(X)

sin(X::Array{Float32}) = Vectorize.Accelerate.sin(X)

asin(X::Array{Float32}) = Vectorize.Accelerate.asin(X)

div!(X::Array{Float32}, Y::Array{Float32}, Z::Array{Float32}) = Vectorize.Accelerate.div!(X, Y, Z)

exp2!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.exp2!(X, Y)

round!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.round!(X, Y)

tanh!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.tanh!(X, Y)

max(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.max(X, Y)

mul!(X::Array{Float32}, Y::Array{Float32}, Z::Array{Float32}) = Vectorize.Accelerate.mul!(X, Y, Z)

sub!(X::Array{Float32}, Y::Array{Float32}, Z::Array{Float32}) = Vectorize.Accelerate.sub!(X, Y, Z)

tan!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.tan!(X, Y)

sin!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.sin!(X, Y)

sumsqr(X::Array{Float32}) = Vectorize.Accelerate.sumsqr(X)

asinh!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.asinh!(X, Y)

atanh!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.atanh!(X, Y)

ceil!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.ceil!(X, Y)

cos!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.cos!(X, Y)

mul(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.mul(X, Y)

expm1!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.expm1!(X, Y)

add(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Yeppp.add(X, Y)

summag(X::Array{Float64}) = Vectorize.Accelerate.summag(X)

sinpi!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.sinpi!(X, Y)

abs(X::Array{Float32}) = Vectorize.Accelerate.abs(X)

log1p!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.log1p!(X, Y)

cos(X::Array{Float32}) = Vectorize.Accelerate.cos(X)

mean(X::Array{Float32}) = Vectorize.Accelerate.mean(X)

cosh!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.cosh!(X, Y)

sin(X::Array{Float64}) = Vectorize.Accelerate.sin(X)

tan(X::Array{Float64}) = Vectorize.Yeppp.tan(X)

max!(X::Array{Float64}, Y::Array{Float64}, Z::Array{Float64}) = Vectorize.Accelerate.max!(X, Y, Z)

trunc(X::Array{Float64}) = Vectorize.Accelerate.trunc(X)

tanh(X::Array{Float32}) = Vectorize.Accelerate.tanh(X)

tanpi(X::Array{Float32}) = Vectorize.Accelerate.tanpi(X)

div(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.div(X, Y)

sumsqr(X::Array{Float64}) = Vectorize.Accelerate.sumsqr(X)

minimum(X::Array{Float64}) = Vectorize.Accelerate.minimum(X)

cosh(X::Array{Float64}) = Vectorize.Accelerate.cosh(X)

max(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.max(X, Y)

sinh(X::Array{Float32}) = Vectorize.Accelerate.sinh(X)

maximum(X::Array{Float64}) = Vectorize.Accelerate.maximum(X)

exponent!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.exponent!(X, Y)

exp2!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.exp2!(X, Y)

invsqrt(X::Array{Float64}) = Vectorize.Accelerate.invsqrt(X)

acos(X::Array{Float32}) = Vectorize.Accelerate.acos(X)

mul!(X::Array{Float64}, Y::Array{Float64}, Z::Array{Float64}) = Vectorize.Accelerate.mul!(X, Y, Z)

exp(X::Array{Float32}) = Vectorize.Accelerate.exp(X)

add!(X::Array{Float64}, Y::Array{Float64}, Z::Array{Float64}) = Vectorize.Accelerate.add!(X, Y, Z)

log1p(X::Array{Float64}) = Vectorize.Accelerate.log1p(X)

acosh!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.acosh!(X, Y)

log2!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.log2!(X, Y)

sinh(X::Array{Float64}) = Vectorize.Accelerate.sinh(X)

acosh(X::Array{Float64}) = Vectorize.Accelerate.acosh(X)

sin!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.sin!(X, Y)

exp(X::Array{Float64}) = Vectorize.Accelerate.exp(X)

exponent(X::Array{Float64}) = Vectorize.Accelerate.exponent(X)

maximum(X::Array{Float32}) = Vectorize.Accelerate.maximum(X)

min!(X::Array{Float32}, Y::Array{Float32}, Z::Array{Float32}) = Vectorize.Accelerate.min!(X, Y, Z)

tanh!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.tanh!(X, Y)

log10(X::Array{Float64}) = Vectorize.Accelerate.log10(X)

floor!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.floor!(X, Y)

expm1!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.expm1!(X, Y)

tanh(X::Array{Float64}) = Vectorize.Accelerate.tanh(X)

acosh!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.acosh!(X, Y)

round(X::Array{Float64}) = Vectorize.Accelerate.round(X)

cos!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Yeppp.cos!(X, Y)

min(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.min(X, Y)

tanpi(X::Array{Float64}) = Vectorize.Accelerate.tanpi(X)

atan(X::Array{Float32}) = Vectorize.Accelerate.atan(X)

floor!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.floor!(X, Y)

tan(X::Array{Float32}) = Vectorize.Accelerate.tan(X)

sinh!(X::Array{Float64}, Y::Array{Float64}) = Vectorize.Accelerate.sinh!(X, Y)

trunc!(X::Array{Float32}, Y::Array{Float32}) = Vectorize.Accelerate.trunc!(X, Y)
