Prev: what are some of the uses for ada?
Next: Library_Symbol_File in Stand-alone Library Projects
From: Colin Paul Gloster on 11 Jun 2010 08:42
On Thursday 10th June 2010, Randy Brukardt sent via Jacob Sparre
Andersen's netnews transfer protocol server:
|---------------------------------------------------------------------------|
|""Jeffrey R. Carter" <spam.jrcarter.not(a)spam.acm.org> wrote in message |
|news:hur95a$3oh$1(a)tornado.tornevall.net... |
|> Colin Paul Gloster wrote: |
|>> |
|>> Though there should be no difference, in reality compilers produce |
|>> less slow machine code when looping down to zero instead of up from |
|>> zero. |
|> |
|> The root of all evil. |
| |
|Goody, we're playing Jeopardy! I assume that was "Programming" for 200. :-)|
| |
|Q: What is premature optimization?? |
| |
| Randy." |
|---------------------------------------------------------------------------|

Jeffrey R. Carter and Randall L. Brukardt,

If any of you claims that you posted an unclear phrase which had not
been intended to be libelous which looks like you accused me of
inappropriately trying to apply premature optimization, then clarify
or be sued for libel. You had already known that I had made major
improvements in speed to simulations which I depend on in order to
stay alive this year (unfortunately the funding shall end in December
2010 no matter how well I do), and that speeding up just one per cent
results in a valuable improvement of hours.

Nasser M. Abbasi was not reverting to Ada as a complement to
Mathematica with the objective of producing slower software than
Mathematica.

Yours sincerely,
Colin Paul Gloster
From: Brian Drummond on 11 Jun 2010 08:00
On Fri, 11 Jun 2010 10:48:37 +0200, "J-P. Rosen" <rosen(a)adalog.fr> wrote:

>Yannick Duch�ne (Hibou57) a �crit :
>> Le Thu, 10 Jun 2010 15:27:38 +0200, J-P. Rosen <rosen(a)adalog.fr> a �crit:
>>> For output, rounding is specified in the standard. And BTW, the standard
>>> does not specify IEEE (fortunately, it did not make the same mistake as
>>> Java!).
>> Which mistake ? (not to disagree, just to understand)
....
>There is an interesting paper on the internet about why Java failed on
>numerics. Sorry, I don't have the exact reference at hand, but it should
>be easy to find.

At a wild guess, easy to find for anyone who's heard of Prof Kahan.

But just in case... I presume you mean
http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf

On the other hand, the abstract starts:
"Java�s floating-point arithmetic is blighted by five gratuitous mistakes:"

So perhaps the original question "which mistake?" still stands;
nos 3) and 4) look particularly bad.

- Brian

From: Randy Brukardt on 11 Jun 2010 14:59
"Colin Paul Gloster" <Colin_Paul_Gloster(a)ACM.org> wrote in message
news:alpine.LNX.2.00.1006111207170.3608(a)Bluewhite64.example.net...
....
> If any of you claims that you posted an unclear phrase which had not
> been intended to be libelous which looks like you accused me of
> inappropriately trying to apply premature optimization, then clarify
> or be sued for libel.

Don't be so sensitive!

Optimization is premature unless there is a demonstrated need for additional
performance.

In any case, being guilty of premature optimization has almost no reflection
on how good or bad of a programmer you are (something I am not in any
position to judge). The best programmers are still guilty of it from time to
time. I know I've been guilty of it multiple times, and it is useful to have
outsiders point that out, in order that I don't repeat the same mistake on
my next project. And it's very useful to repeat the mantra over and over, in
order to reduce the temptation.

> You had already known that I had made major
> improvements in speed to simulations which I depend on in order to
> stay alive this year (unfortunately the funding shall end in December
> 2010 no matter how well I do), and that speeding up just one per cent
> results in a valuable improvement of hours.

Sure there are cases like that; your work application has a demonstrated
need for more performance. Such situations are rare, however. I spent a lot
of effort optimizing lookup times in our spam filter, only to find out that
it wasn't a signifiant percentage of the filtering effort.

And you have to know that I have been writing optimizing Ada compilers for
the last 30 years (well, 29 years and 9 months to be exact), so I know how
to performance optimize when necessary. But...

> Nasser M. Abbasi was not reverting to Ada as a complement to
> Mathematica with the objective of producing slower software than
> Mathematica.

My understanding was that the OP was comparing the readability and
ease-of-creation of Fortran and Ada. I saw no indication that he was
concerned about the performance. And in many cases, the performance of the
code isn't very relevant. (Remember the 90/10 rule!) In the absence of a
demonstrated need for better performance, making the code less readable is a
bad idea, no matter what effect it has on performance. That's exactly the
definition of premature optimization, in my opinion.

Randy.

P.S. I wouldn't waste time on suing someone. Only the lawyers make money in
most lawsuits.


From: Vincent LAFAGE on 14 Jun 2010 05:33
Hi,

I would like to give some comments on your conclusion.
In fact, I have to disagree with this conclusion.

> 1. In Ada, I did not have to change the index of m and k in the
> summation to reflect the 1-off per the definition of DFT.
> DFT starts from 0 to N-1. In Ada, using 'Range and defining the arrays
> to go from 0 .. N-1 solved the problem.

It is a cliche that Fortran's index have to start at 1.
It was already possible in Fortran 77 to start indexes for where you
want it to start.
look for instance at
http://www.physics.nau.edu/~bowman/PHY520/F77tutor/10_arrays.html
real b(0:19), weird(-162:237)

In your case, it would lead to
COMPLEX, dimension (0:N-1) :: X
REAL, dimension (0:N-1) :: data=(/1.0,2.0,3.0/)

In Fortran 90, you do not have the very convenient X'range
but you can use the following statement to keep generality
DO k = lbound (X, 1), ubound (X, 1)

When speaking about Fortran, we should not forget to specify which one,
Fortran 90 being a completely different beast.
As far as we can compare, the writer of Fortran 90 have drawn a lot from
Ada 83.

> 2. In Ada, the compiler complained more times more about types being
> mixed up. I placed float() around the places it complained about.

We can certainly complain about the implicit type promotion of Fortran.
Still modern compiler provides the same safe-guard against the implicit
type promotion of Fortran.
For instance,
$ gfortran-4.3 -Wall -Wsurprising -Wconversion dft.f90 -o dft
will reveal 11 surprising implicit conversion such as
dft.f90:14.29:
COMPLEX, parameter :: J =(0,1)
1
Warning: Conversion from INTEGER(4) to REAL(4) at (1)

So "-Wall" is not the last word as far as warning are concerned.

> 3. It actually took me less time to do the Ada function than the FORTRAN
> one, even though I am equally not familiar with both at this time :)

A 17 Statement Line Of Code example is not really anything close to
realistic example for scaling.
Not only the sample size is small, but what is more, it doesn't scale
linearly, or in the same way.
Besides, you did not tell us how long it took in either case. But that
would be telling... ;)

I am also an Ada enthusiast, but it does not prevent my being a Fortran
enthusiast as well.

Best regards,
Vincent

Le 09/06/2010 12:49, Nasser M. Abbasi a �crit :
> I never used complex variables before in Ada, so for the last 3 hrs I
> was learning how to do it. I wrote a simple program, to find the DFT of
> an array of 3 elements {1,2,3} (DFT=discrete Fourier transform).
>
> The definition of DFT is one equation with summation, here it is, first
> equation you'll see:
>
> http://en.wikipedia.org/wiki/Discrete_Fourier_transform
>
> Since I have not programmed in Ada nor in FORTRAN for a looong time, I
> am very rusty, I program in Mathematica and sometimes in matlab these
> days, but I wanted to try Ada on complex numbers.
>
> I also wrote a FORTRAN equivalent of the small Ada function. Here is
> below the Ada code, and the FORTRAN code. Again, do not scream too much
> if it is not good code, I just learned this now, I am sure this can be
> improved a lot.
>
> And for comparing, I show the Matlab and the Mathematica output just to
> make sure.
>
>
> ====== START ADA ============
> --
> -- dtf.adb, compiled with GNAT 4.3.4 20090804 (release) 1
> -- under CYGWIN 1.7.5
> -- gnatmake dft.adb
> --
> -- ./dft.exe
> -- ( 6.00000E+00, 0.00000E+00)
> -- (-1.50000E+00, 8.66026E-01)
> -- (-1.50000E+00,-8.66025E-01)
> -- $
>
>
> with Ada.Text_IO; use Ada.Text_IO;
> with Ada.Numerics.Complex_Types; use Ada.Numerics.Complex_Types;
>
> with Ada.Numerics; use Ada.Numerics;
>
> with Ada.Numerics.Complex_Elementary_Functions;
> use Ada.Numerics.Complex_Elementary_Functions;
>
> with Ada.Complex_Text_IO; use Ada.Complex_Text_IO;
>
> procedure dft is
> N : positive := 3;
> J : constant complex :=(0.0,1.0); -- SQRT(-1)
> X : array(0 .. N-1) of Complex := (others=>(0.0,0.0));
> data : array(0 .. N-1) of float :=(1.0,2.0,3.0);
>
> begin
> FOR k in X'range LOOP
> FOR m in data'range LOOP
> X(k) := X(k) + data(m) * exp(- J*(2.0*Pi)/float(N) * float(m*k) );
> END LOOP;
> put(X(k)); new_line;
> END LOOP;
>
> end dft;
> ================== END ADA ==============
>
> ======= FORTRAN code ===========
> ! dtf.f90, compiled with GCC 4.3.4
> ! under CYGWIN 1.7.5
> ! gfortran -Wall dft.f90
> ! ./a.exe
> ! ( 6.0000000 , 0.0000000 )
> ! ( -1.4999999 , 0.86602557 )
> ! ( -1.5000005 ,-0.86602497 )
> !
>
> PROGRAM dft
>
> IMPLICIT NONE
>
> INTEGER, PARAMETER :: N = 3
> COMPLEX, parameter :: J =(0,1)
>
> REAL, parameter :: Pi = ACOS(-1.0)
> INTEGER :: k,m
> COMPLEX, dimension(N) :: X
> REAL, dimension(N) :: data=(/1.0,2.0,3.0/)
>
> DO k=1,N
> X(k)=(0,0)
> DO m=1,N
> X(k) = X(k) + data(m) * EXP(-1.0*J*2.0*Pi/N *(m-1)*(k-1) )
> END DO
> print *,X(k)
>
> END DO
>
> END PROGRAM dft
> ==================================
>
> ==== Matlab code ====
> EDU>> fft([1,2,3])'
>
> ans =
>
> 6.0000
> -1.5000 - 0.8660i
> -1.5000 + 0.8660i
> ===============================
>
> === Mathematica ====
> In[5]:= Chop[Fourier[{1, 2, 3}, FourierParameters -> {1, -1}]]
>
> Out[5]= {6., -1.5 + 0.8660254037844386*I, -1.5 - 0.8660254037844386*I}
> =========================
>
> Conclusion:
> I actually liked the Ada implementation more than FORTRAN because:
>
> 1. In Ada, I did not have to change the index of m and k in the
> summation to reflect the 1-off per the definition of DFT.
> DFT starts from 0 to N-1. In Ada, using 'Range and defining the arrays
> to go from 0 .. N-1 solved the problem.
>
> 2. In Ada, the compiler complained more times more about types being
> mixed up. I placed float() around the places it complained about.
>
> 3. It actually took me less time to do the Ada function than the FORTRAN
> one, even though I am equally not familiar with both at this time :)
>
> ok, this was a fun learning exercise
>
>
> --Nasser

From: Nasser M. Abbasi on 14 Jun 2010 08:29
On 6/14/2010 2:33 AM, Vincent LAFAGE wrote:

> For instance,
> $ gfortran-4.3 -Wall -Wsurprising -Wconversion dft.f90 -o dft
> will reveal 11 surprising implicit conversion such as
> dft.f90:14.29:
> COMPLEX, parameter :: J =(0,1)
> 1
> Warning: Conversion from INTEGER(4) to REAL(4) at (1)
>
> So "-Wall" is not the last word as far as warning are concerned.
>

Thanks, I did not know about these flags. I am impressed now with FORTRAN.

The f90 compiler, with those flags added, became as annoying, opps, I
mean as picky as the Ada compiler and complained about all the implicit
conversions.

Also, with the use of lbound and ubound in FORTRAN helped make the
logic simpler by avoiding the 1-off problem.

To update, below is the current version of the example in Ada and
FORTRAN. I also made a small page where I kept these for reference.

http://12000.org/my_notes/mma_matlab_control/KERNEL/node94.htm

I think now it seems to me, from this simple example, that Ada and
FORTRAN can be equally good languages for scientific applications.

Thanks for everyone for the suggestions.

============= Ada ====================
--
-- dtf.adb, compiled with GNAT 4.3.4 20090804 (release) 1
-- under CYGWIN 1.7.5
-- $ gnatmake dft.adb
-- gcc -c dft.adb
-- gnatbind -x dft.ali
-- gnatlink dft.ali
-- $ ./dft.exe
--
-- ( 6.00000E+00, 0.00000E+00)
-- (-1.50000E+00, 8.66026E-01)
-- (-1.50000E+00,-8.66025E-01)

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Numerics.Complex_Types; use Ada.Numerics.Complex_Types;

with Ada.Numerics; use Ada.Numerics;

with Ada.Numerics.Complex_Elementary_Functions;
use Ada.Numerics.Complex_Elementary_Functions;

with Ada.Complex_Text_IO; use Ada.Complex_Text_IO;

procedure dft is
N : constant := 3; -- named number, no conversion to Float needed
X : array(0 .. N-1) of Complex := (others=>(0.0,0.0));
data : constant array(0 .. N-1) of float :=(1.0,2.0,3.0);
Two_Pi_Over_N : constant := 2 * Pi / N;
-- named number, outside the loop, like in ARM 3.3.2(9)
begin
FOR k in X'range LOOP
FOR m in data'range LOOP
X(k) := X(k) + data(m)*exp(-J*Two_Pi_Over_N * float(m*k));
END LOOP;
put(X(k)); new_line;
END LOOP;
end dft;

====================== Fortran ======================
! dtf.f90, compiled with GCC 4.3.4
! under CYGWIN 1.7.5
! $ gfortran -Wall -Wsurprising -Wconversion dft.f90
! $ ./a.exe
! ( 6.0000000 , 0.0000000 )
! ( -1.4999999 , 0.86602557 )
! ( -1.5000005 ,-0.86602497 )
! $

PROGRAM dft

IMPLICIT NONE

INTEGER, parameter :: N = 3
COMPLEX, parameter :: J =(0.0,1.0)
REAL, parameter :: Pi = ACOS(-1.0)
INTEGER :: k,m
COMPLEX, dimension(0:N-1) :: X
REAL, dimension(0:N-1) :: data=(/1.0,2.0,3.0/)
REAL, parameter :: Two_Pi_Over_N = 2.0*Pi/real(N)

DO k = lbound(X, 1), ubound(X, 1)
X(k)=(0.0,0.0)
DO m = lbound(data, 1), ubound(data, 1)
X(k) = X(k) + complex(data(m),0.0) &
* EXP(-J*complex(Two_Pi_Over_N*real(m*k),0.0))
END DO
print *,X(k)
END DO

END PROGRAM dft


--Nasser
First  |  Prev  |  Next  |  Last
Pages: 1 2 3 4 5 6 7
Prev: what are some of the uses for ada?
Next: Library_Symbol_File in Stand-alone Library Projects