Recent changes to homehttps://sourceforge.net/p/qpfloat/home/20160618T00:43:20ZHome modified by coder0xff20160618T00:43:20Z20160618T00:43:20Zcoder0xffhttps://sourceforge.net/u/coder0xff/https://sourceforge.net66c6aa84683c63d09a9f7259bf1cf2e25c2d0d39<div class="markdown_content"><pre> v4
+++ v5
@@ 1,3 +1,4 @@
+Notice: This project has been migrated to GitHub. https://github.com/coder0xff/QPFloat
# QPFloat (GPL 3.0) #
For highprecision mathematics, the QuadruplePrecision Floating Point library (QPFloat) emulates the IEEE 754 2008 binary128 on x86, and x64 (and probably any other littleendian platform) using integer arithmetic and bit manipulation. It contains a native C++ and assembler implementation, and a .Net C++/CLI implementation.
</pre>
</div>WikiPage Home modified by Coder0xff20120421T02:25:10Z20120421T02:25:10ZCoder0xffhttps://sourceforge.net/u/coder0xff/https://sourceforge.netf8fc29e1a6cedd2ec8a71b59172af0e3f234c3ff<pre> 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
</pre>WikiPage Home modified by Coder0xff20110801T23:06:37Z20110801T23:06:37ZCoder0xffhttps://sourceforge.net/u/coder0xff/https://sourceforge.net33b331a71ed7361f0390aeebf3f8aa069aaea1df<pre> v2
+++ v3
@@ 1,47 +1,63 @@
QPFloat (GPL 3.0)
================================================================================

The QuadruplePrecision Floating Point library (QPFloat) emulates the quadruple precision floatingpoint ( IEEE 754 2008 binary128 ) on x86, and x64 (and probably any other littleendian 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 littleendian, may or may not work on bigendian
 Follows the IEEE inmemory format on littleendian machines (transferable to and from hardware)
 arithmetic on subnormals
 roundtoeven
 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 highprecision mathematics, the QuadruplePrecision Floating Point library (QPFloat) emulates the IEEE 754 2008 binary128 on x86, and x64 (and probably any other littleendian 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), arbitrarybase 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 littleendian architecture, may or may not work on bigendian???
+* Strictly follows IEEE specifications to the extent availabile on Wikipedia.
+* Multiple guard bits
+* Arithmetic on subnormals is fully supported.
+* Inf, Inf, and NaN are fully supported.
+* roundtoeven
+* 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.
</pre>WikiPage Home modified by Anonymous Coward20110617T20:33:13Z20110617T20:33:13ZAnonymous Cowardhttps://sourceforge.net/u/%2Aanonymous/https://sourceforge.net5ed67168a0652b6e9689709de006f3625cd3f137<pre> 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 QuadruplePrecision Floating Point library (QPFloat) emulates the quadruple precision floatingpoint ( IEEE 754 2008 binary128 ) on x86, and x64 (and probably any other littleendian 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 littleendian, may or may not work on bigendian
+ Follows the IEEE inmemory format on littleendian machines (transferable to and from hardware)
+ arithmetic on subnormals
+ roundtoeven
+ 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.
</pre>WikiPage Home modified by Anonymous Coward20110617T20:33:13Z20110617T20:33:13ZAnonymous Cowardhttps://sourceforge.net/u/%2Aanonymous/https://sourceforge.net215a8bef7406f088787031e3c0eb3d08945888bbWelcome 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.