floating-point-precision

I have just started working with OpenCL. However, I have found some weird behavior of OpenCl, which i can't understand. The source i built and tested, was http://www.codeproject.com/Articles/110685/Part-1-OpenCL-Portable-Parallelism . I have a ATI Radeon HD 4770, and a AMD Fx 6200 3.8 ghz 6 core cpu. Speed Firstly the speed is not linearly to the number of maximum work group items. I ran App profiler to analyze the time spent during the kernel execution. The result was a bit shocking, my GPU which can only handle 256 work items per group, used 2.23008 milliseconds to calculate square of

In my question about Analysis of float/double precision in 32 decimal digits , one answer said to take a look at __float128 . I used it and the compiler could find it, but I can not print it, since the complier can not find the header quadmath.h . So my questions are: __float128 is standard, correct? How to print it? Isn't quadmath.h standard? These answers did not help: Use extern C Precision in C++ Printing The ref also did not help. Note that I do not want to use any non standard library. [EDIT] It would be also useful, if that question had an answer, even if the answer was a negative one.

I was writing some templated code to benchmark a numeric algorithm using both floats and doubles, in order to compare against a GPU implementation. I discovered that my floating point code was slower and after investigating using Vtune Amplifier from Intel I discovered that g++ was generating extra x86 instructions (cvtps2pd/cvtpd2ps and unpcklps/unpcklpd) to convert some intermediate results from float to double and then back again. The performance degradation is almost 10% for this application. After compiling with the flag -Wdouble-promotion (which BTW is not included with -Wall or -Wextra)

I was working on a project to compute the Leibniz approximation for pi with the below code: def pi(precision): sign = True ret = 0 for i in range(1,precision+1): odd = 2 * i - 1 if sign: ret += 1.0 / odd else: ret -= 1.0 / odd sign = not sign return ret However, the output value was always was 12 digits long. How can I increase the precision (e.g. more digits) of the calculation? Does Python support more precise floating points, or will I have to use some external library? albusshin Try using Decimal . Read Arbitrary-precision elementary mathematical functions (Python) original for more

My problem is that I have to use a thrid-party function/algorithm which takes an array of double -precision values as input, but apparently can be sensitive to very small changes in the input data. However for my application I have to get identical results for inputs that are (almost) identical! In particular I have two test input arrays which are identical up to the 5-th position after the decimal point and still I get different results. So what causes the "problem" must be after the 5-th position after the decimal point. Now my idea was to round the input to a slightly lower precision in

I was delving into multi-precision arithmetics, and there is a nice fast class of algorithms, described in Jonathan Richard Shewchuk, "Adaptive Precision Floating-Point Arithmetic and Fast Robust Geometric Predicates", 1997, Discrete & Computational Geometry, pages: 305–363. However, these algorithms rely on the FPU using round-to-even tiebreaking. On CPU, it would be easy, one would just check or set the FPU state word and would be sure. However, there is no such instruction (yet?) for GPU programming. That is why I was wondering if there is a dependable way of detecting (not setting) the