Skip to content

Commit 5d3be83

Browse files
author
oscarddssmith
committed
fix-ccall
1 parent 312ee80 commit 5d3be83

File tree

2 files changed

+48
-48
lines changed

2 files changed

+48
-48
lines changed

‎ext/QuadMathSpecialFunctionsExt.jl

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,35 +1,35 @@
11
module QuadMathSpecialFunctionsExt
22

3-
using Quadmath: libquadmath, Float128, Cfloat128
3+
using Quadmath: libquadmath, Float128, Cfloat128, @quad_ccall
44
import SpecialFunctions
55
import SpecialFunctions: erf, erfc, besselj0, besselj1, bessely0, bessely1,
66
besselj, bessely, gamma, logabsgamma
77

88
erf(x::Float128) =
9-
Float128(@ccall(libquadmath.erfq(x::Cfloat128)::Cfloat128))
9+
Float128(@quad_ccall(libquadmath.erfq(x::Cfloat128)::Cfloat128))
1010
erfc(x::Float128) =
11-
Float128(@ccall(libquadmath.erfcq(x::Cfloat128)::Cfloat128))
11+
Float128(@quad_ccall(libquadmath.erfcq(x::Cfloat128)::Cfloat128))
1212

1313
besselj0(x::Float128) =
14-
Float128(@ccall(libquadmath.j0q(x::Cfloat128)::Cfloat128))
14+
Float128(@quad_ccall(libquadmath.j0q(x::Cfloat128)::Cfloat128))
1515
besselj1(x::Float128) =
16-
Float128(@ccall(libquadmath.j1q(x::Cfloat128)::Cfloat128))
16+
Float128(@quad_ccall(libquadmath.j1q(x::Cfloat128)::Cfloat128))
1717

1818
bessely0(x::Float128) =
19-
Float128(@ccall(libquadmath.y0q(x::Cfloat128)::Cfloat128))
19+
Float128(@quad_ccall(libquadmath.y0q(x::Cfloat128)::Cfloat128))
2020
bessely1(x::Float128) =
21-
Float128(@ccall(libquadmath.y1q(x::Cfloat128)::Cfloat128))
21+
Float128(@quad_ccall(libquadmath.y1q(x::Cfloat128)::Cfloat128))
2222

2323
besselj(n::Integer, x::Float128) =
24-
Float128(@ccall(libquadmath.jnq(n::Cint, x::Cfloat128)::Cfloat128))
24+
Float128(@quad_ccall(libquadmath.jnq(n::Cint, x::Cfloat128)::Cfloat128))
2525
bessely(n::Integer, x::Float128) =
26-
Float128(@ccall(libquadmath.ynq(n::Cint, x::Cfloat128)::Cfloat128))
26+
Float128(@quad_ccall(libquadmath.ynq(n::Cint, x::Cfloat128)::Cfloat128))
2727

2828
gamma(x::Float128) =
29-
Float128(@ccall(libquadmath.tgammaq(x::Cfloat128)::Cfloat128))
29+
Float128(@quad_ccall(libquadmath.tgammaq(x::Cfloat128)::Cfloat128))
3030

3131
function logabsgamma(x::Float128)
32-
result = Float128(@ccall(libquadmath.lgammaq(x::Cfloat128)::Cfloat128))
32+
result = Float128(@quad_ccall(libquadmath.lgammaq(x::Cfloat128)::Cfloat128))
3333
sign = !isfinite(result) || x >= 0 || !iszero(mod(ceil(x), 2)) ? 1 : -1
3434
return result, sign
3535
end

‎src/Quadmath.jl

Lines changed: 37 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ elseif Sys.iswindows()
4141
const libquadmath = "libquadmath-0.dll"
4242
end
4343

44-
macro ccall(expr)
44+
macro quad_ccall(expr)
4545
@assert expr isa Expr && expr.head == :(::)
4646
ret_type = expr.args[2]
4747

@@ -139,15 +139,15 @@ Float128(x::Float128) = x
139139

140140
# Float64
141141
@assume_effects :foldable Float128(x::Float64) =
142-
Float128(@ccall(quadoplib.__extenddftf2(x::Cdouble)::Cfloat128))
142+
Float128(@quad_ccall(quadoplib.__extenddftf2(x::Cdouble)::Cfloat128))
143143
@assume_effects :foldable Float64(x::Float128) =
144-
@ccall(quadoplib.__trunctfdf2(x::Cfloat128)::Cdouble)
144+
@quad_ccall(quadoplib.__trunctfdf2(x::Cfloat128)::Cdouble)
145145

146146
# Float32
147147
@assume_effects :foldable Float128(x::Float32) =
148-
Float128(@ccall(quadoplib.__extendsftf2(x::Cfloat)::Cfloat128))
148+
Float128(@quad_ccall(quadoplib.__extendsftf2(x::Cfloat)::Cfloat128))
149149
@assume_effects :foldable Float32(x::Float128) =
150-
@ccall(quadoplib.__trunctfsf2(x::Cfloat128)::Cfloat)
150+
@quad_ccall(quadoplib.__trunctfsf2(x::Cfloat128)::Cfloat)
151151

152152
# Float16
153153
Float128(x::Float16) = Float128(Float32(x))
@@ -159,16 +159,16 @@ Float128(x::Base.TwicePrecision{Float64}) =
159159

160160
# integer -> Float128
161161
@assume_effects :foldable Float128(x::Int32) =
162-
Float128(@ccall(quadoplib.__floatsitf(x::Int32)::Cfloat128))
162+
Float128(@quad_ccall(quadoplib.__floatsitf(x::Int32)::Cfloat128))
163163

164164
@assume_effects :foldable Float128(x::UInt32) =
165-
Float128(@ccall(quadoplib.__floatunsitf(x::UInt32)::Cfloat128))
165+
Float128(@quad_ccall(quadoplib.__floatunsitf(x::UInt32)::Cfloat128))
166166

167167
@assume_effects :foldable Float128(x::Int64) =
168-
Float128(@ccall(quadoplib.__floatditf(x::Int64)::Cfloat128))
168+
Float128(@quad_ccall(quadoplib.__floatditf(x::Int64)::Cfloat128))
169169

170170
@assume_effects :foldable Float128(x::UInt64) =
171-
Float128(@ccall(quadoplib.__floatunditf(x::UInt64)::Cfloat128))
171+
Float128(@quad_ccall(quadoplib.__floatunditf(x::UInt64)::Cfloat128))
172172

173173
Float128(x::Int16) = Float128(Int32(x))
174174
Float128(x::Int8) = Float128(Int32(x))
@@ -230,37 +230,37 @@ Float128(x::Bool) = x ? Float128(1) : Float128(0)
230230

231231
# Comparison
232232
@assume_effects :foldable (==)(x::Float128, y::Float128) =
233-
@ccall(quadoplib.__eqtf2(x::Cfloat128, y::Cfloat128)::Cint) == 0
233+
@quad_ccall(quadoplib.__eqtf2(x::Cfloat128, y::Cfloat128)::Cint) == 0
234234
@assume_effects :foldable (<)(x::Float128, y::Float128) =
235-
@ccall(quadoplib.__letf2(x::Cfloat128, y::Cfloat128)::Cint) == -1
235+
@quad_ccall(quadoplib.__letf2(x::Cfloat128, y::Cfloat128)::Cint) == -1
236236
@assume_effects :foldable (<=)(x::Float128, y::Float128) =
237-
@ccall(quadoplib.__letf2(x::Cfloat128, y::Cfloat128)::Cint) <= 0
237+
@quad_ccall(quadoplib.__letf2(x::Cfloat128, y::Cfloat128)::Cint) <= 0
238238

239239
# Arithmetic
240240
@assume_effects :foldable (+)(x::Float128, y::Float128) =
241-
Float128(@ccall(quadoplib.__addtf3(x::Cfloat128, y::Cfloat128)::Cfloat128))
241+
Float128(@quad_ccall(quadoplib.__addtf3(x::Cfloat128, y::Cfloat128)::Cfloat128))
242242
@assume_effects :foldable (-)(x::Float128, y::Float128) =
243-
Float128(@ccall(quadoplib.__subtf3(x::Cfloat128, y::Cfloat128)::Cfloat128))
243+
Float128(@quad_ccall(quadoplib.__subtf3(x::Cfloat128, y::Cfloat128)::Cfloat128))
244244
@assume_effects :foldable (*)(x::Float128, y::Float128) =
245-
Float128(@ccall(quadoplib.__multf3(x::Cfloat128, y::Cfloat128)::Cfloat128))
245+
Float128(@quad_ccall(quadoplib.__multf3(x::Cfloat128, y::Cfloat128)::Cfloat128))
246246
@assume_effects :foldable (/)(x::Float128, y::Float128) =
247-
Float128(@ccall(quadoplib.__divtf3(x::Cfloat128, y::Cfloat128)::Cfloat128))
247+
Float128(@quad_ccall(quadoplib.__divtf3(x::Cfloat128, y::Cfloat128)::Cfloat128))
248248

249249
@assume_effects :foldable (-)(x::Float128) =
250-
Float128(@ccall(quadoplib.__negtf2(x::Cfloat128)::Cfloat128))
250+
Float128(@quad_ccall(quadoplib.__negtf2(x::Cfloat128)::Cfloat128))
251251

252252
# Float128 -> Integer
253253
@assume_effects :foldable unsafe_trunc(::Type{Int32}, x::Float128) =
254-
@ccall(quadoplib.__fixtfsi(x::Cfloat128)::Int32)
254+
@quad_ccall(quadoplib.__fixtfsi(x::Cfloat128)::Int32)
255255

256256
@assume_effects :foldable unsafe_trunc(::Type{Int64}, x::Float128) =
257-
@ccall(quadoplib.__fixtfdi(x::Cfloat128)::Int64)
257+
@quad_ccall(quadoplib.__fixtfdi(x::Cfloat128)::Int64)
258258

259259
@assume_effects :foldable unsafe_trunc(::Type{UInt32}, x::Float128) =
260-
@ccall(quadoplib.__fixunstfsi(x::Cfloat128)::UInt32)
260+
@quad_ccall(quadoplib.__fixunstfsi(x::Cfloat128)::UInt32)
261261

262262
@assume_effects :foldable unsafe_trunc(::Type{UInt64}, x::Float128) =
263-
@ccall(quadoplib.__fixunstfdi(x::Cfloat128)::UInt64)
263+
@quad_ccall(quadoplib.__fixunstfdi(x::Cfloat128)::UInt64)
264264

265265
function unsafe_trunc(::Type{UInt128}, x::Float128)
266266
xu = reinterpret(UInt128,x)
@@ -332,19 +332,19 @@ for f in (:acos, :acosh, :asin, :asinh, :atan, :atanh, :cosh, :cos,
332332
:sin, :sinh, :sqrt, :tan, :tanh,
333333
:ceil, :floor, :trunc, )
334334
@eval @assume_effects :foldable function $f(x::Float128)
335-
Float128(@ccall(libquadmath.$(string(f,:q))(x::Cfloat128)::Cfloat128))
335+
Float128(@quad_ccall(libquadmath.$(string(f,:q))(x::Cfloat128)::Cfloat128))
336336
end
337337
end
338338

339-
@assume_effects :foldable abs(x::Float128) = Float128(@ccall(libquadmath.fabsq(x::Cfloat128)::Cfloat128))
340-
@assume_effects :foldable round(x::Float128) = Float128(@ccall(libquadmath.rintq(x::Cfloat128)::Cfloat128))
339+
@assume_effects :foldable abs(x::Float128) = Float128(@quad_ccall(libquadmath.fabsq(x::Cfloat128)::Cfloat128))
340+
@assume_effects :foldable round(x::Float128) = Float128(@quad_ccall(libquadmath.rintq(x::Cfloat128)::Cfloat128))
341341
round(x::Float128, r::RoundingMode{:Down}) = floor(x)
342342
round(x::Float128, r::RoundingMode{:Up}) = ceil(x)
343343
round(x::Float128, r::RoundingMode{:ToZero}) = round(x)
344344

345345
## two argument
346346
@assume_effects :foldable (^)(x::Float128, y::Float128) =
347-
Float128(@ccall(libquadmath.powq(x::Cfloat128, y::Cfloat128)::Cfloat128))
347+
Float128(@quad_ccall(libquadmath.powq(x::Cfloat128, y::Cfloat128)::Cfloat128))
348348

349349
# circumvent a failure in Base
350350
function (^)(x::Float128, p::Integer)
@@ -355,15 +355,15 @@ function (^)(x::Float128, p::Integer)
355355
end
356356
end
357357
@assume_effects :foldable copysign(x::Float128, y::Float128) =
358-
Float128(@ccall(libquadmath.copysignq(x::Cfloat128, y::Cfloat128)::Cfloat128))
358+
Float128(@quad_ccall(libquadmath.copysignq(x::Cfloat128, y::Cfloat128)::Cfloat128))
359359
@assume_effects :foldable hypot(x::Float128, y::Float128) =
360-
Float128(@ccall(libquadmath.hypotq(x::Cfloat128, y::Cfloat128)::Cfloat128))
360+
Float128(@quad_ccall(libquadmath.hypotq(x::Cfloat128, y::Cfloat128)::Cfloat128))
361361
@assume_effects :foldable atan(x::Float128, y::Float128) =
362-
Float128(@ccall(libquadmath.atan2q(x::Cfloat128, y::Cfloat128)::Cfloat128))
362+
Float128(@quad_ccall(libquadmath.atan2q(x::Cfloat128, y::Cfloat128)::Cfloat128))
363363

364364
Base.Integer(x::Float128) = Int(x)
365365
@assume_effects :foldable Base.rem(x::Float128, y::Float128) =
366-
Float128(@ccall(libquadmath.remainderq(x::Cfloat128, y::Cfloat128)::Cfloat128))
366+
Float128(@quad_ccall(libquadmath.remainderq(x::Cfloat128, y::Cfloat128)::Cfloat128))
367367

368368
sincos(x::Float128) = (sin(x), cos(x))
369369

@@ -372,12 +372,12 @@ sincos(x::Float128) = (sin(x), cos(x))
372372
# disable fma on Windows until rounding mode issue fixed
373373
# https://github.com/JuliaMath/Quadmath.jl/issues/31
374374
@assume_effects :foldable fma(x::Float128, y::Float128, z::Float128) =
375-
Float128(@ccall(libquadmath.fmaq(x::Cfloat128, y::Cfloat128, z::Cfloat128)::Cfloat128))
375+
Float128(@quad_ccall(libquadmath.fmaq(x::Cfloat128, y::Cfloat128, z::Cfloat128)::Cfloat128))
376376
end
377377

378-
@assume_effects :foldable isnan(x::Float128) = 0 != @ccall(libquadmath.isnanq(x::Cfloat128)::Cint)
379-
@assume_effects :foldable isinf(x::Float128) = 0 != @ccall(libquadmath.isinfq(x::Cfloat128)::Cint)
380-
@assume_effects :foldable isfinite(x::Float128) = 0 != @ccall(libquadmath.finiteq(x::Cfloat128)::Cint)
378+
@assume_effects :foldable isnan(x::Float128) = 0 != @quad_ccall(libquadmath.isnanq(x::Cfloat128)::Cint)
379+
@assume_effects :foldable isinf(x::Float128) = 0 != @quad_ccall(libquadmath.isinfq(x::Cfloat128)::Cint)
380+
@assume_effects :foldable isfinite(x::Float128) = 0 != @quad_ccall(libquadmath.finiteq(x::Cfloat128)::Cint)
381381

382382
isinteger(x::Float128) = isfinite(x) && x === trunc(x)
383383

@@ -402,14 +402,14 @@ typemax(::Type{Float128}) = Inf128
402402
typemin(::Type{Float128}) = -Inf128
403403

404404
@assume_effects :foldable ldexp(x::Float128, n::Cint) =
405-
Float128(@ccall(libquadmath.ldexpq(x::Cfloat128, n::Cint)::Cfloat128))
405+
Float128(@quad_ccall(libquadmath.ldexpq(x::Cfloat128, n::Cint)::Cfloat128))
406406
ldexp(x::Float128, n::Integer) =
407407
ldexp(x, clamp(n, typemin(Cint), typemax(Cint)) % Cint)
408408

409409

410410
@assume_effects :foldable function frexp(x::Float128)
411411
ri = Ref{Cint}()
412-
f = Float128(@ccall(libquadmath.frexpq(x::Cfloat128, ri::Ptr{Cint})::Cfloat128))
412+
f = Float128(@quad_ccall(libquadmath.frexpq(x::Cfloat128, ri::Ptr{Cint})::Cfloat128))
413413
return f, Int(ri[])
414414
end
415415

@@ -613,13 +613,13 @@ end
613613

614614
# TODO: need to do this better
615615
function parse(::Type{Float128}, s::AbstractString)
616-
Float128(@ccall(libquadmath.strtoflt128(s::Cstring, C_NULL::Ptr{Ptr{Cchar}})::Cfloat128))
616+
Float128(@quad_ccall(libquadmath.strtoflt128(s::Cstring, C_NULL::Ptr{Ptr{Cchar}})::Cfloat128))
617617
end
618618

619619
function string(x::Float128)
620620
lng = 64
621621
buf = Array{UInt8}(undef, lng + 1)
622-
lng = @ccall(libquadmath.quadmath_snprintf(buf::Ptr{UInt8}, (lng+1)::Csize_t, "%.35Qe"::Ptr{UInt8}, x::(Cfloat128...))::Cint)
622+
lng = @quad_ccall(libquadmath.quadmath_snprintf(buf::Ptr{UInt8}, (lng+1)::Csize_t, "%.35Qe"::Ptr{UInt8}, x::(Cfloat128...))::Cint)
623623
return String(resize!(buf, lng))
624624
end
625625

0 commit comments

Comments
 (0)