Hi all,

Please, allow me to ask this naive question...

I am mainly a programmer in Matlab. Often times for the sake of speed, I
convert my Matlab program into C/C++, often with the aid of numerical
libraries such as GSL, IMSL, MKL, etc.

Now I am facing a numerical computation task which need quadruple precison.
Please see below for a detailed description.

I guess Intel Visual Fortran or other Fortran has natural support for the
quadruple precision.

I probably will have to pick up my Fortran book and do some Fortran
programming. (I've touched a little bit of it some years ago).

Now, speed if critical for my application. If somebody tells me that
Fortran's support of Quadruple precision is about 10%% faster than any other
quadruple solution in any other libraries in C/C++, then I am going to turn
to Fortran.

If the consensus is that Fortran for numerical calculations is only 5%%
faster than C/C++, then I won't bother turn to Fortran.

Thanks!

I can't think of a human problem that needs anywhere near 128 bits of
floating point.
Some integer problems I can believe do require absolute accuracy (e.g.
checking you really have found the factores of a very large integer or
for being prime. Also accountants count the very largest amounts in
the most worthless currencies down to the cents that only exist on
paper - even when the thousands denominated tokens are worthless tiny
impure metal objects.

There ARE problems where it is mportant to not lose so much
calculation precision as to not achieve the final objctive with any
accuracy. But as far as I know, all these problema can be resolved in
a way where an approximate solution, with variables being assigned
values which bear close relationship to the truth, allow moving the
starting point of the algorithm to this new startimg approximation and
making another calculation pass. (Normalization). The solutions
usually converge at a reasonable rate to the desired solution with any
desired degre of accureacy, if you proceed.

Terence wrote:

(snip)

Yes, those kind of problems. It might be possible to do other
ways, but sometimes high precision is the best way when you can't
be sure of another way. Or sometimes just to verify that the
other way does give the appropriately close answer.

-- glen

"Vista" gmai.com> writes:

This really depends on what you want to do. Fortran compilers
typically optimize for loops over large arrays, often employing loop
interchange, prefetching and blocking, which few (if any?) C/C++
compilers do. C++ can do some of the same optimisations by carefully
writing template libraries that instantiate code to specific array
sizes. I have heard of (at least) FFT and matrix multiply functions
made this way.

So, with good libraries, C++ may match Fortran on large array
operations, but if you need large-array code that isn't matched by an
existing optimized library, you might get more speed out of an
optimizing Fortran compiler.

For code that isn't dominated by loops over large arrays, I doubt
there is much speed difference between a good C/C++ compiler and a
good Fortran compiler.

You could also consider more modern languages like Clean, OCaml or
SML.

I think that is a false criteria on the whole.

One aspect where Fortran per se, has the edge over C, is that Fortran does
not allow aliasing but C does.
So technically a Fotran compiler could make extra optimisations that a C
compiler cannot make.
But this academic, as every C compiler I have seen has switches that allow
the compiler to make some assumptions about aliasing, so in practice, they
are level.

But in terms of support for "Quadruple precision", really that depends on
the compiler implementation not language.
You could easily find a compiler of different languages - ADA, Delphi, C++
that might be faster here.

On Fri, 06 Jul 2007 13:29:28 +0100, Stephen Howe wrote:

"Isaac Gouy" yahoo.com> wrote in message
news:1183741034.825083.266470@d30g2000prg.googlegroups.com...

The shootout rules are designed for C programmers, not Fortran
programmers. Whereas a Fortran programmer would look at a
problem statement, carry out some analysis, then compose a
brilliant innovative solution, a C programmer would have to
search for a pre-existing solution, likely in Fortran, then
code it up in C. The pre-existing solutions prescribed in the
shootout page are at least in some cases a couple of orders of
magnitude slower than optimal algorithms.

In article <7zr6nmvty4.fsf@app-5.diku.dk>,
Torben

On Jul 6, 10:32 am, "James Van Buskirk" comcast.net> wrote:

-snip-

James Van Buskirk wrote:

You sure say a lot of nonsense in that post. From the imaginary class
difference between Fortran programmers and C programmers and the imaginary
border which separates both groups, to the claim that C is " an assembly
language for a long-dead CPU", not to mention that ridiculous assertion
about the learning curve of both languages. For a troll you sure put up a
whole lot of efford into that post.

Rui Maciel