* Re: small example, using complex variables in Ada
2010-06-14 12:29 11% ` Nasser M. Abbasi
@ 2010-06-14 13:00 0% ` Vincent LAFAGE
0 siblings, 0 replies; 6+ results
From: Vincent LAFAGE @ 2010-06-14 13:00 UTC (permalink / raw)
If we want not only compile-time warning but also run time check
-fbounds-check
like in
gfortran -Wall -Wsurprising -Wconversion -fbounds-check dft.f90 -o dft
It can be pretty useful, and close to some of the runtime checks of Ada.
So, if we remember some larger scale results I provided in a former
thread, with Ada and Fortran being equally good for coding numerical
application, Fortran 90 is still twice as fast with complex...
Vincent
PS: on a completely different level, we may use less UPPERCASE, as most
of us are more used to read lower-case or Capitalized.
Particularly for reserved words.
It's less work for our poor programmer's brain.
The same goes for the languages' names as Fortran is no more in
all-uppercase since Fortran 90, and ADA is the American Dental
Association. ;)
Le 14/06/2010 14:29, Nasser M. Abbasi a �crit :
> 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
^ permalink raw reply [relevance 0%]
* Re: small example, using complex variables in Ada
2010-06-14 9:33 0% ` Vincent LAFAGE
@ 2010-06-14 12:29 11% ` Nasser M. Abbasi
2010-06-14 13:00 0% ` Vincent LAFAGE
0 siblings, 1 reply; 6+ results
From: Nasser M. Abbasi @ 2010-06-14 12:29 UTC (permalink / raw)
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
^ permalink raw reply [relevance 11%]
* Re: small example, using complex variables in Ada
2010-06-09 10:49 10% small example, using complex variables in Ada Nasser M. Abbasi
2010-06-09 11:26 14% ` Ludovic Brenta
@ 2010-06-14 9:33 0% ` Vincent LAFAGE
2010-06-14 12:29 11% ` Nasser M. Abbasi
1 sibling, 1 reply; 6+ results
From: Vincent LAFAGE @ 2010-06-14 9:33 UTC (permalink / raw)
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
^ permalink raw reply [relevance 0%]
* Re: Ada noob here! Is Ada widely used?
@ 2010-06-09 16:26 12% ` Robert A Duff
0 siblings, 0 replies; 6+ results
From: Robert A Duff @ 2010-06-09 16:26 UTC (permalink / raw)
"Nasser M. Abbasi" <nma@12000.org> writes:
> But why no predefined package for complex IO also?
These are also defined by the language, and implemented
in GNAT:
Ada.Complex_Text_IO (a-coteio.ads)
Ada.Long_Complex_Text_IO (a-lcteio.ads)
Ada.Long_Long_Complex_Text_IO (a-llctio.ads)
Ada.Short_Complex_Text_IO (a-scteio.ads)
> Ada.Text_IO.Complex_IO is generic package, and I have to instantiate it
> for float to do complex IO? May be I overlooked something.
They're easy to overlook in the RM, because the entire
package spec is not shown -- just a short paragraph
describing what they look like. See G.1.3(9.1/2).
As far as I know, all of the generic numerics stuff
has pre-instantiated versions for Float, Long_Float, etc.
- Bob
^ permalink raw reply [relevance 12%]
* Re: small example, using complex variables in Ada
2010-06-09 10:49 10% small example, using complex variables in Ada Nasser M. Abbasi
@ 2010-06-09 11:26 14% ` Ludovic Brenta
2010-06-14 9:33 0% ` Vincent LAFAGE
1 sibling, 0 replies; 6+ results
From: Ludovic Brenta @ 2010-06-09 11:26 UTC (permalink / raw)
On Jun 9, 12:49 pm, "Nasser M. Abbasi" <n...@12000.org> wrote:
> 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
You should use constants and named numbers instead of variables
wherever possible; this simplifies your Ada program. Also, i and j are
predefined so you do not need to declare a "new" value for J:
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;
--
Ludovic Brenta.
^ permalink raw reply [relevance 14%]
* small example, using complex variables in Ada
@ 2010-06-09 10:49 10% Nasser M. Abbasi
2010-06-09 11:26 14% ` Ludovic Brenta
2010-06-14 9:33 0% ` Vincent LAFAGE
0 siblings, 2 replies; 6+ results
From: Nasser M. Abbasi @ 2010-06-09 10:49 UTC (permalink / raw)
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
^ permalink raw reply [relevance 10%]
Results 1-6 of 6 | reverse | options above
-- pct% links below jump to the message on this page, permalinks otherwise --
2010-05-20 12:53 Ada noob here! Is Ada widely used? Duke Normandin
2010-05-20 18:49 ` Gautier write-only
2010-06-05 8:04 ` Nasser M. Abbasi
2010-06-05 9:24 ` Yannick Duchêne (Hibou57)
2010-06-05 12:59 ` Dmitry A. Kazakov
2010-06-05 16:02 ` Nasser M. Abbasi
2010-06-05 18:50 ` Robert A Duff
2010-06-09 6:31 ` Nasser M. Abbasi
2010-06-09 16:26 12% ` Robert A Duff
2010-06-09 10:49 10% small example, using complex variables in Ada Nasser M. Abbasi
2010-06-09 11:26 14% ` Ludovic Brenta
2010-06-14 9:33 0% ` Vincent LAFAGE
2010-06-14 12:29 11% ` Nasser M. Abbasi
2010-06-14 13:00 0% ` Vincent LAFAGE
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox