MathGroup Archive 2008

[Date Index] [Thread Index] [Author Index]

Search the Archive

Anyone with experience showing graphically, how data flows between

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

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


*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