FWIW I've looked into quad precision a bit and it's pretty widely available
via one compiler: GCC provides __float128 (or maybe without the
underscores?).

Late-model Intel compiler supports the same (and not _Quad, it seems).
Fortran 2008 requires float128, so most compilers have to have impl
eventually, if they aim to support ISO Fortran.

Only IBM z-series and Fujitsu have ever done it in hardware AFAIK. But I am
only 34 so maybe QP was ubiquitous back when I was only an egg :-)

I think Boost has non-GPL float128 else most software impls are GPL. But
SoftFloat and other Berkeley efforts by Bailey are BSD (naturally).

Best,

Jeff

On Tuesday, September 29, 2015, Brad Chamberlain <[email protected]> wrote:
>
>
> * You mention quad precision arithmetic, which is something that Chapel
>   does not support at present.  We discussed adding it early in the
>   project's history, but at that time, it was difficult to predict
>   how support for quad precision might vary across machines, so we left
>   it out for the time being.  I suspect adding it in would not be
>   terribly complicated for a back-end C compiler with good support for
>   it, but I mostly wanted to emphasize that it is not available today.
>
> Hope this is helpful,
> -Brad
>
>
> On Tue, 29 Sep 2015, Tom MacDonald wrote:
>
> Hi Mikel,
>>
>> The Chapel team is racing toward a release this week and
>> it might take us a few days to respond. We appreciate your
>> interest and Chapel and ask for a little patience.
>>
>> Best wishes,
>>
>> Tom MacDonald
>> Chapel Manager
>>
>> On Tue, 29 Sep 2015, Mikel AntoƱana wrote:
>>
>> Hi,
>>>
>>> I have developed an numerical integration algorithm in language C and  I
>>> ask
>>> myself if I should programme it in Chapel to get better performance.
>>> Next,
>>> I  give a short description of the algorithm.
>>>
>>>  A huge number of integration steps are taken.
>>>  Only a small part of the code can be evaluated in parallel (I have used
>>> Open MP model)  and  the ?fun? evaluation is expensive.
>>> The units of work to run in parallel is small (p.e ns=6),  so  I carry
>>> out
>>> the computation in a multicore desktop.
>>>  I need to increase the accuracy of the solution and in the next future,
>>> I
>>> will make some computations using  quadruple precision arithmetic.
>>>
>>>
>>>   Algorithm
>>>
>>>              for k=1 to steps
>>>                 {
>>>                         .....
>>>                        #      pragma omp parallel for
>>> num_threads(thread_count) private(isn)
>>>
>>>                               for (is = 0; is<ns; is++)
>>>                                {
>>>                                    isn=neq*is;
>>>                                    fun
>>> (neq,u,&z[isn],&fz[isn],params,thestatptr);
>>>                               }
>>>                       .....
>>>                 }
>>>
>>>
>>> I thank you sincerely your opinion.
>>>
>>>
>>> Regards,
>>> Mikel.
>>>
>>>
>>>
>>>
>>>
>>>
>>>

-- 
Jeff Hammond
[email protected]
http://jeffhammond.github.io/
------------------------------------------------------------------------------
_______________________________________________
Chapel-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/chapel-users

Reply via email to