Services & Resources / Wolfram Forums
-----
 /
MathGroup Archive
2005
*January
*February
*March
*April
*May
*June
*July
*August
*September
*October
*November
*December
*Archive Index
*Ask about this page
*Print this page
*Give us feedback
*Sign up for the Wolfram Insider

MathGroup Archive 2005

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

Search the Archive

Re: Compile nested loops with depending index variables...

  • To: mathgroup at smc.vnet.net
  • Subject: [mg61471] Re: Compile nested loops with depending index variables...
  • From: "Jens-Peer Kuska" <kuska at informatik.uni-leipzig.de>
  • Date: Wed, 19 Oct 2005 23:07:20 -0400 (EDT)
  • Sender: owner-wri-mathgroup at wolfram.com

Hi,

it is clear that
a[[i]]=a[[i]]+b[[i]]
can't be done in a compiled function, because
this would require, that the argument a is not
evaluated. Using a local variable to store the result
require that the array is initialized in the compiled
function and for the initialization, you has to run
over all subscripts anyway.  I think

MapThread[F,{a,b},4]

will do the job perfectly, without any 
compilation.

Regards
  Jens

"Christoph Lhotka" <lhotka at astro.univie.ac.at> 
schrieb im Newsbeitrag 
news:dj4oof$gl6$1 at smc.vnet.net...
| First thank you all, but the main problem is 
still unbsolved.
|
| My specific problem is, that I have two 
rectangular arrays say a and b of
| about 500 000 numbers (complex or real) each. I 
want to create a new array of
| the same dimension and length, where each 
element has to be constructed by a
| law depending on the position in above lists of 
the form:
|
| a[[i,j,k,l]]=F[a[[i,j,k,l]],b[[i,j,k,l]]]
|
| (where F means some function based on basic 
arithmetics)
|
| IT IS NOT NECESSARY TO RUN THROUGH ALL INDICES! 
SO IF i=I0, j<i, k<j, l<k for
| any I0=1,...,n!
|
| To save computation time I wanted to compile and 
didn't succeed. Using a small
| C++ program and MathLink will speed it up, but 
transferring millions of
| numbers from the kernel to the C program and 
vice versa seems to slow it down
| again.
|
| I think that it should be a basic feature for 
any compiler to understand such
| a basic code construct like:
|
| 
Do[a[[i,j,k,l]]=a[[i,j,k,l]]+b[[i,j,k,l]],{i,1,n},{j,1,i},{k,1,j},{l,1,k}],
|
| but it doesn't work.
|
| Won't you agree with me?
|
| kind regards
|
| Christoph
|
|
|
|
| On Sun, 16 Oct 2005 00:17:54 -0400 (EDT)
| albert <awnl at arcor.de> wrote:
| > Hi Christoph,
| >
| > this is from the HelpBrowser about Compile:
| >
| > o Nested lists given as input to a compiled 
function must be full arrays of
| > numbers.
| >
| >
| > the table you construct is not a "full array 
of numbers", since the length
| > of each element is different:
| >
| > In[4]:= Length /@ Table[{i,j},{i,0,n},{j,0,i}]
| >
| > Out[4]= {1, 2, 3, 4}
| >
| > and obviously Compile not only doesn't like 
this sort of nested lists as
| > input but also can't handle these anyware 
within the compiled code. This is
| > not too surprising but not explicitly 
documented so. So I think if you
| > really need to compile your code you need to 
change it in such a way that
| > it constructs a "full array", e.g. the 
following compiles fine:
| >
| > fc = Compile[{n}, Table[If[j <= i, {i, j}, 
{-1, -1}], {i, 0, n}, {j, 0,
| > n}]]
| >
| > you could then reconstruct the original nested 
list by:
| >
| > DeleteCases[fc[2], {-1, -1}, Infinity]
| >
| > It depends on your actual problem whether this 
is more efficient than not
| > compiling, and usually only trying out will 
give you the answer. Memory
| > usage is of course worse than when using the 
not compiled nested Table...
| >
| > This is another approach that is probably more 
memory efficient:
| >
| > fc = Compile[{{i, _Integer}}, Table[{i, j}, 
{j, 0, i}]]
| > ffc = Function[{n}, Table[fc[i], {i, 0, n}]]
| >
| > note that using Function instead of ffc[n_] is 
often slightly more
| > efficient
| > because you avoid complicated pattern 
matching. The drawback is that you
| > can't do checks about correct input that 
easily (like in ffc[n_Integer])...
| >
| > just try what is the most efficient way for 
your problem, I wouldn't
| > exclude
| > that not compiling gives you the fastest code 
in the end...
| >
| > hth
| >
| > albert
| >
|
| -- Mag. Christoph Lhotka --
| University of Vienna / Institute for Astronomy
| mail. lhotka at astro.univie.ac.at
| 



  • Prev by Date: Re: Derivatives of numerical functions : how does mathematica work?
  • Next by Date: Re: Memory use by NMaximize (and NMinimize)
  • Previous by thread: Re: Re: Re: Compile nested loops with depending index variables...
  • Next by thread: region bounded by surfaces