Services & Resources / Wolfram Forums
-----
 /
MathGroup Archive
1995
*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 1995

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

Search the Archive

Re: How to construct pure expressions

  • To: mathgroup at christensen.cybernetics.net
  • Subject: [mg733] Re: [mg631] How to construct pure expressions
  • From: villegas (Robert Villegas)
  • Date: Wed, 12 Apr 1995 01:53:17 -0500
  • Keywords: MapIndexed, index, atom
  • Organization: Wolfram Research, Inc.

> x[
>    x1[
>       x11[
>          x111[ x1111, x1112, x1113],
>          x112[ x1121, x1122, x1123],
>          x113[ x1131, x1132, x1133]
>       ],

..

> In general, the list will have following properties:
> * All expressions has a head that starts with the letter x.
> 
> * The number after x correspond to the position list of that element.  
For 
> example, x211 is an element with position {2,1,1}.
> 
> * The number of digits following x correspond to the level of that  
element.
> For example,  x111, x211 are elements in level 3, x1 or x2 is in level  
1, 
> x is in level 0 because it has zero digits following x.


Hello Xah,

If you first make a dummy array that has the right structure, and then
replace all the entries and the heads with "x" of the indices, you
can do it with a short command.  Note that all the places where your
example wants x... are atomic, in that they're either bottom-level
entries or they are heads.  In Mathematica, this means we want to target
level {-1} and we want Heads->True.

Example for a 2 x 2 matrix, but slightly modifying the form of the x's
from your example, just as an illustration:


In[1]:= MapIndexed[x @@ DeleteCases[#2, 0] &,
          Table[Null, {3}, {3}], {-1}, Heads->True]
        
Out[1]= x[][x[1][x[1, 1], x[1, 2], x[1, 3]], x[2][x[2, 1], x[2, 2], x[2,  
3]], 
 
>    x[3][x[3, 1], x[3, 2], x[3, 3]]]


That makes it clear what MapIndexed is doing, and we can then just
embellish it by replacing the "x @@ DeleteCases" business with a
pre-defined function that takes care of creating the "x" symbols:


MakeSymbol[base_String, {indices___, 0} | {indices___}] :=
  ToExpression @ StringJoin[base, ToString /@ {indices}]


IndexedExpression[base_String, dims:{___Integer?Positive}] :=
  MapIndexed[MakeSymbol["x", #2]&, Array[Null &, dims], {-1}, Heads->True]

(* I switched to using Array to make the code simpler given the way
your example inputs dimensions *)



Here's a test:


In[4]:= IndexedExpression["x", {3, 3, 3}]

Out[4]= x[x1[x11[x111, x112, x113], x12[x121, x122, x123], 
 
>     x13[x131, x132, x133]], x2[x21[x211, x212, x213], 
 
>     x22[x221, x222, x223], x23[x231, x232, x233]], 
 
>    x3[x31[x311, x312, x313], x32[x321, x322, x323], x33[x331, x332,  
x333]]]


Robby Villegas


  • Prev by Date: Re: Performance of student version of Mathematica?
  • Next by Date: Re: Accuracy and Precision
  • Previous by thread: How to construct pure expressions
  • Next by thread: Mm <-> Lisp on mac ?