Fix a few errors, replace README, add basic tests

Author: simonbyrne

LICENSE

@@ -1,6 +1,6 @@
 Float128 is licensed under the MIT License:
 
-Copyright (c) 2016: Harald Hofstätter
+Copyright (c) 2016: Harald Hofstätter, Simon Byrne
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -1,59 +1,12 @@
 # Quadmath.jl
-Float128 and libquadmath for the Julia language
 
-##Installation
-```julia
-Pkg.clone("https://github.com/HaraldHofstaetter/Quadmath.jl")
-Pkg.build("Quadmath")
-```
-##Examples
-To get easy access to the examples, copy them into the home directory:
+This is a Julia interface to libquadmath, providing a `Float128` type corresponding to the IEEE754 binary128 floating point format.
+
+## Installation
 ```julia
-cp(joinpath(homedir(), ".julia/v0.4/Quadmath/examples/"), joinpath(homedir(), "Quadmath_examples"))
+Pkg.clone("https://github.com/simonbyrne/Quadmath.jl")
 ```
-Then 'Quadmath_examples' will be listed in the JuliaBox home screen. The examples contain among others
-+ [BesselZeros.ipynb](https://github.com/HaraldHofstaetter/Quadmath.jl/blob/master/examples/BesselZeros.ipynb):
-  In this notebook it is demonstrated that `Float128` is about 4 times faster than `BigFloat` with 113 bit precision 
-  (the precision of `Float128`).
-
-##Bugs
-+  `ccall` does not treat parameters and returning values of Julia type `Float128` properly as C type `__float128`.
-
-    Unfortunately, this is a bug which cannot easily be fixed without modifying the internals of Julia. 
-    The [x86-64 Application Binary Interface](http://www.x86-64.org/documentation.html) 
-    says that parameters and returning values of type `__float128` should be passed preferably in the (128 bit long) SSE       floating point registers `xmm0`,...,`xmm7`. However, for the datatype `Float128` defined as
-    ```julia
-    bitstype 128 Float128 <: AbstractFloat
-    ```
-    in [Quadmath.jl](https://github.com/HaraldHofstaetter/Quadmath.jl/blob/master/src/Quadmath.jl), 
-    `ccall` seems to use the same calling convention as for something like 
-    ```c
-    struct{ 
-        uint64_t u0; 
-        uint64_t u1;
-    } words64;
-    ``` 
-    in C.
-    
-    As a remedy, you can implement a wrapper function for each external function with `__float128` parameters 
-    or return values, that you want to call with `ccall`. Such a wrapper takes parameters `x` of type 
-    `myfloat128` declared as
-    ```c
-    typedef union
-    {
-      __float128 value;
-
-      struct{
-        uint64_t u0;
-        uint64_t u1;
-      } words64;
-    } myfloat128;
-    ```
-    and calls the original function with `x.value` as actual parameter for the corresponding formal parameter of type
-    `__float128`. 
-    This is exactly the technique we use in 
-    [quadmath_wrapper.c](https://github.com/HaraldHofstaetter/Quadmath.jl/blob/master/deps/src/quadmath_wrapper.c)
-    to call the functions of the [libquadmath](https://gcc.gnu.org/onlinedocs/libquadmath/) library.
-    
 
+## Acknowledgements
 
+Thank you to Harald Hofstätter, who provided the first iteration of [Quadmath.jl](https://github.com/HaraldHofstaetter/Quadmath.jl).

REQUIRE

@@ -1 +1 @@
-julia 0.4-
+julia 0.5

src/Quadmath.jl

@@ -1,12 +1,11 @@
-# This file is modelled after https://github.com/JuliaLang/julia/blob/master/base/mpfr.jl
-# which implements the BigFloat type
-
 __precompile__()
 module Quadmath
 
 export Float128, Complex256
 
-import Base: (*), +, -, /,  <, <=, ==, >, >=, ^, convert, reinterpret,
+import Base: (*), +, -, /,  <, <=, ==, ^, convert,
+          reinterpret, sign_mask, exponent_mask, exponent_one, exponent_half,
+          significand_mask,
           promote_rule, widen,
           string, print, show, showcompact, parse,
           acos, acosh, asin, asinh, atan, atanh, cosh, cos,
@@ -22,6 +21,8 @@ import Base: (*), +, -, /,  <, <=, ==, >, >=, ^, convert, reinterpret,
 
 const libquadmath = "libquadmath.0"
 
+# we use this slightly cumbersome definition to ensure that the value is passed
+# on the xmm registers, matching the x86_64 ABI for __float128.
 typealias Cfloat128 NTuple{2,VecElement{Float64}}
 
 immutable Float128 <: AbstractFloat
@@ -33,8 +34,8 @@ typealias Complex256 Complex{Float128}
 
 Base.cconvert(::Type{Cfloat128}, x::Float128) = x.data
 
-# reinterpret
 
+# reinterpret
 function reinterpret(::Type{UInt128}, x::Float128)
     hi = reinterpret(UInt64, x.data[2].value)
     lo = reinterpret(UInt64, x.data[1].value)
@@ -45,12 +46,22 @@ function reinterpret(::Type{Float128}, x::UInt128)
     flo = reinterpret(Float64, x % UInt64)
     Float128((VecElement(flo), VecElement(fhi)))
 end
+reinterpret(::Type{Unsigned}, x::Float128) = reinterpret(UInt128, x)
+
 reinterpret(::Type{Int128}, x::Float128) =
     reinterpret(Int128, reinterpret(UInt128, x))
 reinterpret(::Type{Float128}, x::Int128) =
     reinterpret(Float128, reinterpret(UInt128, x))
 
 
+sign_mask(::Type{Float128}) =        0x8000_0000_0000_0000_0000_0000_0000_0000
+exponent_mask(::Type{Float128}) =    0x7fff_0000_0000_0000_0000_0000_0000_0000
+exponent_one(::Type{Float128}) =     0x3fff_0000_0000_0000_0000_0000_0000_0000
+exponent_half(::Type{Float128}) =    0x3ffe_0000_0000_0000_0000_0000_0000_0000
+significand_mask(::Type{Float128}) = 0x0000_ffff_ffff_ffff_ffff_ffff_ffff_ffff
+
+fpinttype(::Type{Float128}) = UInt128
+
 # conversion
 
 ## Float64
@@ -80,13 +91,13 @@ convert(::Type{Float128}, x::Clong) =
 # comparison
 
 (==)(x::Float128, y::Float128) =
-    0 != ccall((:__eqtf2,libquadmath), Cint, (Cfloat128,Cfloat128), x, y)
+    ccall((:__eqtf2,libquadmath), Cint, (Cfloat128,Cfloat128), x, y) == 0
 
 (<)(x::Float128, y::Float128) =
-    0 != ccall((:__lttf2,libquadmath), Cint, (Cfloat128,Cfloat128), x, y)
+    ccall((:__letf2,libquadmath), Cint, (Cfloat128,Cfloat128), x, y) == -1
 
 (<=)(x::Float128, y::Float128) =
-    0 != ccall((:__letf2,libquadmath), Cint, (Cfloat128,Cfloat128), x, y)
+    ccall((:__letf2,libquadmath), Cint, (Cfloat128,Cfloat128), x, y) <= 0
 
 # arithmetic
 

test/runtests.jl

@@ -0,0 +1,10 @@
+using Base.Test
+using Quadmath
+
+@test Float128(1) + Float128(2) == Float128(3)
+@test Float128(1) + Float128(2) <= Float128(3)
+@test Float128(1) + Float128(2) != Float128(4)
+@test Float128(1) + Float128(2) < Float128(4)
+@test Float64(Float128(1) + Float128(2)) === 3.0
+
+@test Base.exponent_one(Float128) == reinterpret(UInt128, Float128(1))