Recent changes to Home

Home modified by coder0xff

coder0xff — Sat, 18 Jun 2016 00:43:20 -0000

--- v4
+++ v5
@@ -1,3 +1,4 @@
+Notice: This project has been migrated to GitHub. https://github.com/coder0xff/QPFloat
 # QPFloat (GPL 3.0) #

 For high-precision mathematics, the Quadruple-Precision Floating Point library (QPFloat) emulates the IEEE 754 2008 binary128 on x86, and x64 (and probably any other little-endian platform) using integer arithmetic and bit manipulation. It contains a native C++ and assembler implementation, and a .Net C++/CLI implementation.

WikiPage Home modified by Coder0xff

Coder0xff — Sat, 21 Apr 2012 02:25:10 -0000

--- v3 
+++ v4 
@@ -4,7 +4,7 @@
 
 ## Features ##
 
-Much effort has been put into supporting a full feature set, including optimized transcendental functions to full precision.
+Much effort has been put into supporting a full feature set, including optimized transcendental functions and string conversion to full precision.
 
 ### Standard operations ###
 * addition, subtraction, multiplication, division

WikiPage Home modified by Coder0xff

Coder0xff — Mon, 01 Aug 2011 23:06:37 -0000

--- v2 
+++ v3 
@@ -1,47 +1,63 @@
-QPFloat (GPL 3.0)
-================================================================================
-
-The Quadruple-Precision Floating Point library (QPFloat) emulates the quadruple precision floating-point ( IEEE 754 2008 binary128 ) on x86, and x64 (and probably any other little-endian platform) using integer arithmetic and bit manipulation. It includes:
-    Primitive operations such as addition, subtraction, multiplication, and division
-    Higher operations such as natural logarithm, arbitrary base logarithm, exp, and pow
-    Cieling, Floor, Round, Truncate, and Fraction (Fraction returns just the fractional portion)
-    Sin, Cos, Tan, ASin, ACos, ATan, ATan2 implemented using Maclaurin series
-    ToString and FromString function
-    Hard coded constants such as Pi and e to full quadruple precision
-    Implemented on little-endian, may or may not work on big-endian
-    Follows the IEEE in-memory format on little-endian machines (transferable to and from hardware)
-    arithmetic on sub-normals
-    round-to-even
-    correct propogation Inf, -Inf, and NaN
-    enablable exception mechanisms
-    
-    This library contains both an unmanaged implementation and a managed implementation (atop the unmanaged).
-    
-***** USING *****
-
-VB.Net and C# users:
-    Add a reference to Release/QPFloat.dll (x64/Release/QPFloat.dll for x64)
-    create new variables using the System.Quadruple type (C# can do "using System;" so that you can just type Quadruple)
-    
-VC++/CLI users:
-    Add a reference to Release/QPFloat.dll (x64/Release/QPFloat.dll for x64)
-    create new variables using System::Quadruple
-    
-C++ users:
-    Add a reference to Release/QPFloat.dll (x64/Release/QPFloat.dll for x64)
-    #include "__float128.h"
-    create new variables using __float128
-
-***** COMPILING *****
-
-Microsoft Visual C++ users:
-    This code base can be compiled with or without /clr (Managed C++) to the compiler.
-    If /clr IS used, then this library can be used by C# and VB.Net via the type Quadruple, the same way as Double
-    If /clr IS NOT used, #ifdef _MANAGED has been used to automatically exclude the managed implementation.
-    Since extension methods can't be used to add static functions to System.Math, Operations like Abs, Sin, etc are static methods of Quadruple
-    __float128 is the unmanaged (faster) implementation, which is still present even when /clr is used.
-    
-Other compiler users:
-    This code uses #ifdef to remove Microsoft specific functionality automatically (#ifdef _MANAGED)
-    Though I've not tried, it should be relatively easy to build using other compilers.
-    following existing conventions, __float128 is the type proffered by this library.
+# QPFloat (GPL 3.0) #
+
+For high-precision mathematics, the Quadruple-Precision Floating Point library (QPFloat) emulates the IEEE 754 2008 binary128 on x86, and x64 (and probably any other little-endian platform) using integer arithmetic and bit manipulation. It contains a native C++ and assembler implementation, and a .Net C++/CLI implementation.
+
+## Features ##
+
+Much effort has been put into supporting a full feature set, including optimized transcendental functions to full precision.
+
+### Standard operations ###
+* addition, subtraction, multiplication, division
+* Min, Max, Abs, Ceiling, Floor, Round, Truncate, Fraction
+* ToString and FromString
+* Cast operators to and from native numeric data types
+
+### Numeric information ###
+* IsZero
+* IsNaN
+* IsInfinite
+* IsSigned
+* IsSubNormal
+
+### Transcendental functions ###
+* natural logarithm (Ln), arbitrary-base logarithm (Log)
+* exponentiation (Exp)
+* power function (Pow)
+* Sin, Cos, Tan
+* ASin, ACos, ATan, ATan2
+
+### Miscellaneous features ###
+* Fast! Optimized low level bit manipulation
+* Hard coded constant Pi and E to full quadruple precision
+* Implemented on little-endian architecture, may or may not work on big-endian???
+* Strictly follows IEEE specifications to the extent availabile on Wikipedia.
+* Multiple guard bits
+* Arithmetic on sub-normals is fully supported.
+* Inf, -Inf, and NaN are fully supported.
+* round-to-even
+* emulates FPU exceptions with enable/disable flags (default: all disabled)
+       
+## Using ##
+
+### VB.Net, C# users, and C++/CLI ###
+1. Add a reference to Release/QPFloat.dll (x64/Release/QPFloat.dll for x64)
+2. Create new variables using System.Quadruple
+    
+### C++ users ###
+1. Add a reference to QPFloat.dll (x64/Release/QPFloat.dll for x64)
+2. include "__float128.h"
+3. create new variables using __float128
+
+## Compiling ##
+
+### Microsoft Visual C++ ###
+* This code base can be compiled with or without /clr (Managed C++) to the compiler.
+* If /clr IS used, then this library can be used by C#, VB.Net, and C++/CLI via the type System.Quadruple.
+* If /clr IS NOT used, #ifdef _MANAGED has been used to automatically exclude the managed implementation.
+* Since extension methods can't be used to add static functions to System.Math, Operations like Abs, Sin, etc are static methods of Quadruple.
+* __float128 is the unmanaged (faster) implementation, which is still present even when /clr is used.
+    
+### Other compilers ###
+* This code uses #ifdef to remove Microsoft specific functionality automatically (#ifdef _MANAGED)
+* Though I've not tried, it should be relatively easy to build using other compilers.
+* following existing conventions, __float128 is the type proffered by this library.

WikiPage Home modified by Anonymous Coward

Anonymous Coward — Fri, 17 Jun 2011 20:33:13 -0000

--- v1 
+++ v2 
@@ -1,5 +1,47 @@
-Welcome to your wiki!
-
-This is the default page, edit it as you see fit. To add a page simply reference it within brackets, e.g.: [SamplePage].
-
-The wiki uses [Markdown](/p/qpfloat/home/markdown_syntax/) syntax.
+QPFloat (GPL 3.0)
+================================================================================
+
+The Quadruple-Precision Floating Point library (QPFloat) emulates the quadruple precision floating-point ( IEEE 754 2008 binary128 ) on x86, and x64 (and probably any other little-endian platform) using integer arithmetic and bit manipulation. It includes:
+    Primitive operations such as addition, subtraction, multiplication, and division
+    Higher operations such as natural logarithm, arbitrary base logarithm, exp, and pow
+    Cieling, Floor, Round, Truncate, and Fraction (Fraction returns just the fractional portion)
+    Sin, Cos, Tan, ASin, ACos, ATan, ATan2 implemented using Maclaurin series
+    ToString and FromString function
+    Hard coded constants such as Pi and e to full quadruple precision
+    Implemented on little-endian, may or may not work on big-endian
+    Follows the IEEE in-memory format on little-endian machines (transferable to and from hardware)
+    arithmetic on sub-normals
+    round-to-even
+    correct propogation Inf, -Inf, and NaN
+    enablable exception mechanisms
+    
+    This library contains both an unmanaged implementation and a managed implementation (atop the unmanaged).
+    
+***** USING *****
+
+VB.Net and C# users:
+    Add a reference to Release/QPFloat.dll (x64/Release/QPFloat.dll for x64)
+    create new variables using the System.Quadruple type (C# can do "using System;" so that you can just type Quadruple)
+    
+VC++/CLI users:
+    Add a reference to Release/QPFloat.dll (x64/Release/QPFloat.dll for x64)
+    create new variables using System::Quadruple
+    
+C++ users:
+    Add a reference to Release/QPFloat.dll (x64/Release/QPFloat.dll for x64)
+    #include "__float128.h"
+    create new variables using __float128
+
+***** COMPILING *****
+
+Microsoft Visual C++ users:
+    This code base can be compiled with or without /clr (Managed C++) to the compiler.
+    If /clr IS used, then this library can be used by C# and VB.Net via the type Quadruple, the same way as Double
+    If /clr IS NOT used, #ifdef _MANAGED has been used to automatically exclude the managed implementation.
+    Since extension methods can't be used to add static functions to System.Math, Operations like Abs, Sin, etc are static methods of Quadruple
+    __float128 is the unmanaged (faster) implementation, which is still present even when /clr is used.
+    
+Other compiler users:
+    This code uses #ifdef to remove Microsoft specific functionality automatically (#ifdef _MANAGED)
+    Though I've not tried, it should be relatively easy to build using other compilers.
+    following existing conventions, __float128 is the type proffered by this library.

WikiPage Home modified by Anonymous Coward

Anonymous Coward — Fri, 17 Jun 2011 20:33:13 -0000

Welcome to your wiki! This is the default page, edit it as you see fit. To add a page simply reference it within brackets, e.g.: [SamplePage]. The wiki uses [Markdown](/p/qpfloat/home/markdown_syntax/) syntax.