library locations

Author: HaraldHofstaetter

deps/src/Makefile

@@ -22,7 +22,7 @@ LIBMPFR =  /usr/lib/x86_64-linux-gnu/libmpfr.so.4
 
 
 OBJS = quadmath_wrapper.o get_float128.o  set_float128.o
-#LIBS += -lquadmath -L/usr/lib/x86_64-linux-gnu -lmpfr -lgmp -lm
+LIBS += $(LIBMPFR) -lquadmath -lm
 #LIBS += -lquadmath -lm
 
 # Figure out OS and architecture

src/Quadmath.jl

@@ -1,6 +1,6 @@
-module float128
+module Quadmath
 
-export Complex256
+export Float128, Complex256
 
 import 
     Base: +, -, (*), /, <, <=, ==, >, >=, ^, convert, promote_rule,
@@ -18,22 +18,23 @@ import
 
 import Base.GMP: ClongMax, CulongMax, CdoubleMax
 
-#bitstype 128 Float128  <: AbstractFloat # this is in base/boot.jl
+bitstype 128 Float128  <: AbstractFloat # this is in base/boot.jl
 #Note: with "<: AbstracFloat" multiplication of two Float128 numbers
 #mysteriously doesn't work!
 
 typealias Complex256 Complex{Float128}
 
-
+const libquadmath_wrapper = joinpath(dirname(@__FILE__),
+                            "..", "deps", "usr", "lib", "libquadmath_wrapper.so")
 
 convert(::Type{Float128}, x::Float128) = x
 
 convert(::Type{Float128}, x::Clong) = 
-            ccall((:convert_qsi, :libfloat128), Float128, ( Clong, ), x )
+            ccall((:convert_qsi, libquadmath_wrapper), Float128, ( Clong, ), x )
 convert(::Type{Float128}, x::Culong) = 
-            ccall((:convert_qui, :libfloat128), Float128, ( Culong, ), x )
+            ccall((:convert_qui, libquadmath_wrapper), Float128, ( Culong, ), x )
 convert(::Type{Float128}, x::Float64) = 
-            ccall((:convert_qd, :libfloat128), Float128, ( Float64, ), x )
+            ccall((:convert_qd, libquadmath_wrapper), Float128, ( Float64, ), x )
 
 #convert(::Type{Float128}, x::Integer) = Float128(BigInt(x))
 
@@ -45,14 +46,14 @@ convert(::Type{Float128}, x::Rational) = Float128(num(x)) / Float128(den(x))
 
 ## Float128 -> AbstractFloat
 convert(::Type{Float64}, x::Float128) =
-    ccall((:convert_dq,:libfloat128), Float64, (Float128,), x)
+    ccall((:convert_dq,libquadmath_wrapper), Float64, (Float128,), x)
 convert(::Type{Float32}, x::Float128) =
-    ccall((:convert_fq,:libfloat128), Float32, (Float128,), x)
+    ccall((:convert_fq,libquadmath_wrapper), Float32, (Float128,), x)
 
 call(::Type{Float64}, x::Float128, r::RoundingMode) =
-    ccall((:convert_dq,:libfloat128), Float64, (Float128,), x)
+    ccall((:convert_dq,libquadmath_wrapper), Float64, (Float128,), x)
 call(::Type{Float32}, x::Float128, r::RoundingMode) =
-    ccall((:convert_fq,:libfloat128), Float32, (Float128,), x)
+    ccall((:convert_fq,libquadmath_wrapper), Float32, (Float128,), x)
 # TODO: avoid double rounding
 call(::Type{Float16}, x::Float128, r::RoundingMode) =
     convert(Float16, call(Float32, x, r))
@@ -63,42 +64,42 @@ promote_rule{T<:AbstractFloat}(::Type{Float128},::Type{T}) = Float128
 
 
 function tryparse(::Type{Float128}, s::AbstractString, base::Int=0)
-    Nullable(ccall((:set_str_q, :libfloat128), Float128, (Cstring, ), s))
+    Nullable(ccall((:set_str_q, libquadmath_wrapper), Float128, (Cstring, ), s))
 end
 
 # Basic arithmetic without promotion
 for (fJ, fC) in ((:+,:add), (:-,:sub), (:/,:div), (:(*),:mul))
     @eval begin
         #Float128
         function ($fJ)(x::Float128, y::Float128)
-            ccall(($(string(fC,:_q)),:libfloat128), Float128, (Float128, Float128), x, y)
+            ccall(($(string(fC,:_q)),libquadmath_wrapper), Float128, (Float128, Float128), x, y)
         end
 
         #Unsigned Integer
         function ($fJ)(x::Float128, y::CulongMax)
-            ccall(($(string(fC,:_qui)),:libfloat128), Float128, (Float128, Culong), x, y)
+            ccall(($(string(fC,:_qui)),libquadmath_wrapper), Float128, (Float128, Culong), x, y)
         end
 
         function ($fJ)(x::CulongMax, y::Float128)
-            ccall(($(string(fC,:_uiq)),:libfloat128), Float128, (Culong, Float128), x, y)
+            ccall(($(string(fC,:_uiq)),libquadmath_wrapper), Float128, (Culong, Float128), x, y)
         end
 
         #Signed Integer
         function ($fJ)(x::Float128, y::ClongMax)
-            ccall(($(string(fC,:_qsi)),:libfloat128), Float128, (Float128, Clong), x, y)
+            ccall(($(string(fC,:_qsi)),libquadmath_wrapper), Float128, (Float128, Clong), x, y)
         end
 
         function ($fJ)(x::ClongMax, y::Float128)
-            ccall(($(string(fC,:_siq)),:libfloat128), Float128, (Clong, Float128), x, y)
+            ccall(($(string(fC,:_siq)),libquadmath_wrapper), Float128, (Clong, Float128), x, y)
         end
 
         # Float32, Float64
         function ($fJ)(x::Float128, y::CdoubleMax)
-            ccall(($(string(fC,:_qd)),:libfloat128), Float128, (Float128, Cdouble), x, y)
+            ccall(($(string(fC,:_qd)),libquadmath_wrapper), Float128, (Float128, Cdouble), x, y)
         end
 
         function ($fJ)(x::CdoubleMax, y::Float128,)
-            ccall(($(string(fC,:_dq)),:libfloat128), Float128, (Cdouble, Float128), x, y)
+            ccall(($(string(fC,:_dq)),libquadmath_wrapper), Float128, (Cdouble, Float128), x, y)
         end
     end
 end
@@ -108,43 +109,43 @@ for (fJ, fC) in ((:+,:cadd), (:-,:csub), (:/,:cdiv), (:(*),:cmul))
     @eval begin
         #Float128
         function ($fJ)(x::Complex256, y::Complex256)
-            ccall(($(string(fC,:_q)),:libfloat128), Complex256, (Complex256, Complex256), x, y)
+            ccall(($(string(fC,:_q)),libquadmath_wrapper), Complex256, (Complex256, Complex256), x, y)
         end
 
         #Unsigned Integer
         function ($fJ)(x::Complex256, y::CulongMax)
-            ccall(($(string(fC,:_qui)),:libfloat128), Complex256, (Complex256, Culong), x, y)
+            ccall(($(string(fC,:_qui)),libquadmath_wrapper), Complex256, (Complex256, Culong), x, y)
         end
 
         function ($fJ)(x::CulongMax, y::Complex256)
-            ccall(($(string(fC,:_uiq)),:libfloat128), Complex256, (Culong, Complex256), x, y)
+            ccall(($(string(fC,:_uiq)),libquadmath_wrapper), Complex256, (Culong, Complex256), x, y)
         end
 
         #Signed Integer
         function ($fJ)(x::Complex256, y::ClongMax)
-            ccall(($(string(fC,:_qsi)),:libfloat128), Complex256, (Complex256, Clong), x, y)
+            ccall(($(string(fC,:_qsi)),libquadmath_wrapper), Complex256, (Complex256, Clong), x, y)
         end
 
         function ($fJ)(x::ClongMax, y::Complex256)
-            ccall(($(string(fC,:_siq)),:libfloat128), Complex256, (Clong, Complex256), x, y)
+            ccall(($(string(fC,:_siq)),libquadmath_wrapper), Complex256, (Clong, Complex256), x, y)
         end
 
         # Float32, Float64
         function ($fJ)(x::Complex256, y::CdoubleMax)
-            ccall(($(string(fC,:_qd)),:libfloat128), Complex256, (Complex256, Cdouble), x, y)
+            ccall(($(string(fC,:_qd)),libquadmath_wrapper), Complex256, (Complex256, Cdouble), x, y)
         end
 
         function ($fJ)(x::CdoubleMax, y::Complex256,)
-            ccall(($(string(fC,:_dq)),:libfloat128), Complex256, (Cdouble, Complex256), x, y)
+            ccall(($(string(fC,:_dq)),libquadmath_wrapper), Complex256, (Cdouble, Complex256), x, y)
         end
 
         # Float128
         function ($fJ)(x::Complex256, y::Float128)
-            ccall(($(string(fC,:_qD)),:libfloat128), Complex256, (Complex256, Float128), x, y)
+            ccall(($(string(fC,:_qD)),libquadmath_wrapper), Complex256, (Complex256, Float128), x, y)
         end
 
         function ($fJ)(x::Float128, y::Complex256,)
-            ccall(($(string(fC,:_Dq)),:libfloat128), Complex256, (Float128, Complex256), x, y)
+            ccall(($(string(fC,:_Dq)),libquadmath_wrapper), Complex256, (Float128, Complex256), x, y)
         end
 
     end
@@ -158,58 +159,58 @@ for (fJ, fC) in ((:<,:less), (:<=,:less_equal), (:(==),:equal), (:>=,:greater_eq
     @eval begin
         #Float128
         function ($fJ)(x::Float128, y::Float128)
-            ccall(($(string(fC,:_q)),:libfloat128), Cint, (Float128, Float128), x, y) != 0
+            ccall(($(string(fC,:_q)),libquadmath_wrapper), Cint, (Float128, Float128), x, y) != 0
         end 
 
         #Unsigned Integer
         function ($fJ)(x::Float128, y::CulongMax)
-            ccall(($(string(fC,:_qui)),:libfloat128), Cint, (Float128, Culong), x, y) != 0
+            ccall(($(string(fC,:_qui)),libquadmath_wrapper), Cint, (Float128, Culong), x, y) != 0
         end
 
         function ($fJ)(x::CulongMax, y::Float128)
-            ccall(($(string(fC,:_uiq)),:libfloat128), Cint, (Culong, Float128), x, y) != 0
+            ccall(($(string(fC,:_uiq)),libquadmath_wrapper), Cint, (Culong, Float128), x, y) != 0
         end
 
         #Signed Integer
         function ($fJ)(x::Float128, y::ClongMax)
-            ccall(($(string(fC,:_qsi)),:libfloat128), Cint, (Float128, Clong), x, y) != 0
+            ccall(($(string(fC,:_qsi)),libquadmath_wrapper), Cint, (Float128, Clong), x, y) != 0
         end
 
         function ($fJ)(x::ClongMax, y::Float128)
-            ccall(($(string(fC,:_siq)),:libfloat128), Cint, (Clong, Float128), x, y) != 0
+            ccall(($(string(fC,:_siq)),libquadmath_wrapper), Cint, (Clong, Float128), x, y) != 0
         end
 
         # Float32, Float64
         function ($fJ)(x::Float128, y::CdoubleMax)
-            ccall(($(string(fC,:_qd)),:libfloat128), Cint, (Float128, Cdouble), x, y) != 0
+            ccall(($(string(fC,:_qd)),libquadmath_wrapper), Cint, (Float128, Cdouble), x, y) != 0
         end
 
         function ($fJ)(x::CdoubleMax, y::Float128,)
-            ccall(($(string(fC,:_dq)),:libfloat128), Cint, (Cdouble, Float128), x, y) != 0
+            ccall(($(string(fC,:_dq)),libquadmath_wrapper), Cint, (Cdouble, Float128), x, y) != 0
         end     
     end
 end
 
 
 function fma(x::Float128, y::Float128, z::Float128)
-    ccall(("fma_q",:libfloat128), Float128, (Float128, Float128, Float128, ), x, y, z)
+    ccall(("fma_q",libquadmath_wrapper), Float128, (Float128, Float128, Float128, ), x, y, z)
 end
 
 
 function -(x::Float128)
-    ccall((:neg_q, :libfloat128), Float128, (Float128,), x)
+    ccall((:neg_q, libquadmath_wrapper), Float128, (Float128,), x)
 end
 
 function ^(x::Float128, y::Float128)
-    ccall((:pow_q, :libfloat128), Float128, (Float128, Float128,), x, y)
+    ccall((:pow_q, libquadmath_wrapper), Float128, (Float128, Float128,), x, y)
 end
 
 # constants
-eps(::Type{Float128}) = ccall(("eps_q", :libfloat128), Float128, (), )
-realmin(::Type{Float128}) = ccall(("realmin_q", :libfloat128), Float128, (), )
-realmax(::Type{Float128}) = ccall(("realmax_q", :libfloat128), Float128, (), )
-convert(::Type{Float128}, ::Irrational{:π}) =  ccall(("pi_q", :libfloat128), Float128, (), )
-convert(::Type{Float128}, ::Irrational{:e}) =  ccall(("e_q", :libfloat128), Float128, (), )
+eps(::Type{Float128}) = ccall(("eps_q", libquadmath_wrapper), Float128, (), )
+realmin(::Type{Float128}) = ccall(("realmin_q", libquadmath_wrapper), Float128, (), )
+realmax(::Type{Float128}) = ccall(("realmax_q", libquadmath_wrapper), Float128, (), )
+convert(::Type{Float128}, ::Irrational{:π}) =  ccall(("pi_q", libquadmath_wrapper), Float128, (), )
+convert(::Type{Float128}, ::Irrational{:e}) =  ccall(("e_q", libquadmath_wrapper), Float128, (), )
 
 
 
@@ -219,56 +220,56 @@ for f in (:acos, :acosh, :asin, :asinh, :atan, :atanh, :cosh, :cos,
           :tan, :tanh, :besselj0, :besselj1, :bessely0, :bessely1, :abs, 
           :ceil, :floor, :trunc, :round, :gamma, :lgamma, ) 
     @eval function $f(x::Float128)
-        ccall(($(string(f,:_q)), :libfloat128), Float128, (Float128, ), x)
+        ccall(($(string(f,:_q)), libquadmath_wrapper), Float128, (Float128, ), x)
     end
 end
 
 for f in (:atan2, :copysign,  :max, :min, :hypot,)
    @eval function $f(x::Float128, y::Float128)
-        ccall(($(string(f,:_q)), :libfloat128), Float128, (Float128, Float128), x, y)
+        ccall(($(string(f,:_q)), libquadmath_wrapper), Float128, (Float128, Float128), x, y)
     end
 end
 
 for f in (:besselj, :bessely,)
     @eval function $f(n::Integer, x::Float128)
-        ccall(($(string(f,:_q)), :libfloat128), Float128, (Cint, Float128), n, x)
+        ccall(($(string(f,:_q)), libquadmath_wrapper), Float128, (Cint, Float128), n, x)
     end
 end
 
 function -(x::Complex256)
-    ccall((:cneg_q, :libfloat128), Complex256, (Complex256,), x)
+    ccall((:cneg_q, libquadmath_wrapper), Complex256, (Complex256,), x)
 end
 
 function ^(x::Complex256, y::Complex256)
-    ccall((:cpow_q, :libfloat128), Complex256, (Complex256, Complex256,), x, y)
+    ccall((:cpow_q, libquadmath_wrapper), Complex256, (Complex256, Complex256,), x, y)
 end
 
 # unary complex functions
 for f in (:acos, :acosh, :asin, :asinh, :atan, :atanh, :cosh, :cos,
           :exp, :log, :log10, :conj, :sin, :sinh, :sqrt,
           :tan, :tanh, ) 
     @eval function $f(x::Complex256)
-        ccall(($(string(:c,f,:_q)), :libfloat128), Complex256, (Complex256, ), x)
+        ccall(($(string(:c,f,:_q)), libquadmath_wrapper), Complex256, (Complex256, ), x)
     end
 end
 
 # unary complex functions with real result
 for f in (:abs, :imag, :real, :angle )
     @eval function $f(x::Float128)
-        ccall(($(string(:c,f,:_q)), :libfloat128), Float128, (Complex256, ), x)
+        ccall(($(string(:c,f,:_q)), libquadmath_wrapper), Float128, (Complex256, ), x)
     end
 end
 
 function cis(x::Float128)
-    ccall((:ccis_q, :libfloat128), Complex256, (Float128,), x)
+    ccall((:ccis_q, libquadmath_wrapper), Complex256, (Float128,), x)
 end
 
 
 
 function string(x::Float128)
     lng = 64 
     buf = Array(UInt8, lng + 1)
-    lng = ccall((:stringq,:libfloat128), Int32, (Ptr{UInt8}, Culong, Ptr{UInt8}, Float128,), buf, lng + 1, "%.35Qe", x)
+    lng = ccall((:stringq,libquadmath_wrapper), Int32, (Ptr{UInt8}, Culong, Ptr{UInt8}, Float128,), buf, lng + 1, "%.35Qe", x)
     return bytestring(pointer(buf), lng)
 end
 
@@ -280,12 +281,12 @@ const ROUNDING_MODE = Cint[0]
 
 function convert(::Type{BigFloat}, x::Float128)
     z = BigFloat()
-    res = ccall((:mpfr_set_float128_xxx, :libfloat128), Int32, (Ptr{BigFloat}, Float128, Int32), &z, x, ROUNDING_MODE[end])
+    res = ccall((:mpfr_set_float128_xxx, libquadmath_wrapper), Int32, (Ptr{BigFloat}, Float128, Int32), &z, x, ROUNDING_MODE[end])
     return z
 end
 
 convert(::Type{Float128}, x::BigFloat) =
-    ccall((:mpfr_get_float128_xxx, :libfloat128), Float128, (Ptr{BigFloat},Int32), &x, ROUNDING_MODE[end])
+    ccall((:mpfr_get_float128_xxx, libquadmath_wrapper), Float128, (Ptr{BigFloat},Int32), &x, ROUNDING_MODE[end])
 
 
 end