Anyone with experience showing graphically, how data flows between

• To: mathgroup at smc.vnet.net
• Subject: [mg89845] Anyone with experience showing graphically, how data flows between
• From: stephenmck at gmail.com
• Date: Sun, 22 Jun 2008 03:25:04 -0400 (EDT)

```Hi, Any suggestions??

I've got two algorithms, the 1st computes the sum the series of input
values x(m) times a coefficient over a range N
ie. X(k)=Sum[ x(m)*Coeff[i], 0, N ]

and another optimised version of the same algorithm where it is
defined recursively
ie. X(k)=Sum[  x(m)*Coeff[i] + Sum[ x(m)*Coeff[i], 0, N1  ], 0, N2  ]

I need to show graphically a call graph or tree structure of the links
between each of the operations.  The idea is that I want to show how
data is passed between operations in the first algoritm (since its
essentially a matrix vector multiply) compared to the second.

I'm new to mathematica, so was having trouble even getting the
algorithm its self to work, but it was recommended to me as the best
way to show this graphically.  My alternative is to count the index
seperation on the summations but not sure this is possible here
either.

Any help from a pro would be very much welcome as this isn't really my
field.

Thanks,
Stephen

*For anyone interested in the context:
The first algorithm I want to show is the discrete Fourier transform
(DFT) and the second is the more efficient version (FFT). I have
designed a variation on the standard FFT with increased data locality
between operations and want to show this graphically compared to the
standard FFT and the DFT.  (I think this should show up well in the
tree structure of the operation calls).  The transform is implemented
in reprogrammable hardware, where short interconnect (from the
locality of data from the last operation and where it will be needed
for the next operation)  between multi core processors is vital to
power consumption.

```

• Prev by Date: Re: Compiling SingularValueDecomposition
• Next by Date: Re: Question - Cluster Analysis
• Previous by thread: Re: Mathematica performance improvements
• Next by thread: simple Sin