Mathematica 9 is now available
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: For Loop and Array related

  • To: mathgroup at smc.vnet.net
  • Subject: [mg58003] Re: [mg57971] For Loop and Array related
  • From: Sseziwa Mukasa <mukasa at jeol.com>
  • Date: Thu, 16 Jun 2005 05:36:03 -0400 (EDT)
  • References: <200506150958.FAA29716@smc.vnet.net>
  • Sender: owner-wri-mathgroup at wolfram.com

On Jun 15, 2005, at 5:58 AM, mchangun at gmail.com wrote:

> Hi All,
>
> I have an array with 100 elements, all set to zero initially.  Then I
> want to randomly choose one element and increase its value by one, and
> repeat this 16000 times. Here is my code:
>
> Lattice = Table[0, {n, 100}];
> For[i = 1, i = 16000, i++, Lattice[[Random[Integer, {1, 100}]]]++]
>
> So now if I add all the elements in the list Lattice together, I  
> should
> get 16000 (I use Total[Lattice] to get the sum of the list).  But this
> doesn't happen, and strangely, each time I run this, the sum of the
> list is different!  What am I doing wrong?
>

Using ++ (Increment) with the expression lattice[[Random[Integer, 
{1,100}]]] is part of your problem.  Increment appears to evaluate  
its argument in a very odd way, you can see this if you use trace.   
Random effectively gets called twice and the assigned value is  
indeterminate.  For example:

In[146]:=
a=Table[0,{3}];
Trace[a[[Random[Integer,{1,3}]]]++]
a
Out[147]=
{a[[Random[Integer,{1,3}]]]]++,{{a,{0,0,
         0}},{Random[Integer,{1,3}],
       3},{0,0,0}[[3]],
     0},{a[[Random[Integer,{1,3}]]]=1,
     1},0}
Out[148]=
{0,1,0}

You can see that Random was evaluated once resulting in a value of 3,  
then the third element of the list was extracted, resulting in a 0,  
then that value was incremented resulting in a 1, and now the  
important part: Random is called again (for some reason Trace doesn't  
show that but the expression a[[Random[Integer,{1,3}]]]=1 necessarily  
means that Random is evaluated again, in this case resulting in a  
value of 2 (we can infer that from the result), then the result of  
the incremented value from the first call to Random is assigned to  
the element at the second call of Random.  I wish I could explain the  
logic more plainly, but I can't imagine how, I hope you can follow.

Anyway the moral of this lesson is not to call Random in expressions  
that use Increment because the result is probably not what you intended.

> Also I'm aware that a lot of Mathematica newbies try and write code
> like it were C++ and I think i've fallen into this trap as well.   
> So is
> there a different (more Mathematica) way which I can implement the
> above?

Basically your problem is you're fighting with the Mathematica  
evaluator, and you're right; your expectations based on languages  
like C are incorrect in this case.  The structure you are searching  
for is called a composition, and you can generate those using the  
Combinatorica function RandomComposition eg.

<<DiscreteMath`Combinatorica`
lattice=RandomComposition[16000,100]

(By the way when programming in Mathemetica it's best to use lower  
case characters to define variables to avoid potential name  
conflicts).  If you are curious how RandomCompositions works you can use

??RandomComposition

Regards,

Ssezi


  • Prev by Date: Re: problem with InverseLaplaceTransform
  • Next by Date: Re: plot3D over a triangular domain
  • Previous by thread: Re: For Loop and Array related
  • Next by thread: Re: For Loop and Array related