From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-0.3 required=5.0 tests=BAYES_00,
	REPLYTO_WITHOUT_TO_CC autolearn=no autolearn_force=no version=3.4.4
X-Google-Thread: 103376,47fc49812a5e8e38,start
X-Google-NewGroupId: yes
X-Google-Attributes: gida07f3367d7,domainid0,public,usenet
X-Google-Language: ENGLISH,ASCII-7-bit
Path: 
 g2news1.google.com!news3.google.com!feeder1.cambriumusenet.nl!feed.tweaknews.nl!193.201.147.78.MISMATCH!feeder.news-service.com!de-l.enfer-du-nord.net!feeder2.enfer-du-nord.net!gegeweb.org!aioe.org!not-for-mail
From: "Nasser M. Abbasi" <nma@12000.org>
Newsgroups: comp.lang.ada
Subject: small example, using complex variables in Ada
Date: Wed, 09 Jun 2010 03:49:37 -0700
Organization: Aioe.org NNTP Server
Message-ID: <hunrki$ph7$1@speranza.aioe.org>
Reply-To: nma@12000.org
NNTP-Posting-Host: c00eBs/j4mUkprxQFmXQpg.user.speranza.aioe.org
Mime-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
X-Complaints-To: abuse@aioe.org
X-Notice: Filtered by postfilter v. 0.8.2
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US;
 rv:1.9.1.9) Gecko/20100317 Thunderbird/3.0.4
Xref: g2news1.google.com comp.lang.ada:11503
Date: 2010-06-09T03:49:37-07:00
List-Id: <comp.lang.ada>

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