Follow-up to : trying to use "get" inside a Maxima function - problem using hashed arrays (FYI)

A simpler way of doing what Leo suggests is:

mtx(T, val, prop):= (
  arraymake(T,['val]) :: val,
  arraymake(T,['rank]) :: prop,
  T)

Not sure why you'd want to do this, though.

            -s


On Fri, Mar 18, 2011 at 06:32, Leo Butler <l.butler at ed.ac.uk> wrote:

>
>
> On Thu, 17 Mar 2011, Stavros Macrakis wrote:
>
> < Bruce,
> < I think there is a confusion here.  You said you wanted to attach a
> quality to a *variable*.  But I don't think that's what you wanted to do.
>  You want a *value* which includes both the matrix and some additional
> properties.
> <  After all, if you attach a quality to a variable, that quality won't be
> assigned or bound to a different variable when you assign or bind the
> *value* of that variable to *another* variable.
> <
> < Back to the container vs. the contents.  If you put a green apple in a
> red box, it doesn't become red, and if you transfer the contents of the red
> box to a blue box, it is no longer in a red box (and of course it remains
> < green).
> <
> < There is yet another possibility.  If the qualities you're assigning are
> not *additional* annotations which vary from case to case, but in fact
> properties of the value itself, you *can* use hashed arrays, but instead of
> < something like variable['property_name]: property_value, you'd use
> property_name[object_value]: property_value.  For example, you could have
> prime[3]:true or factors[12]:[2,3,4,6].  In the matrix case, this could be
> useful for
> < (e.g.) annotating a matrix as upper-diagonal or not.  But it would *not*
> be useful to attach the basis, since the same matrix value can be used with
> different bases.
> <
> <             -s
> <
> <
> <
> < On Wed, Mar 16, 2011 at 11:44, Bruce Linnell <brlinnell at verizon.net>
> wrote:
> <       Recap : my original goal was to attach a "quality" to a
> variable that has a value, so that when the variable was passed to a
> function, the function could take the appropriate steps based on the
> quality.  In
> <       particular, I'm trying to add to the CTensor package functionality,
> which requires knowing whether a tensor has upper and/or lower indices.  My
> goal is to be able to manipulate vectors, matrices, and arrays
> <       containing equations in order to multiply tensors, take the
> covariant derivative of them, raise/lower indices, etc.
>
> Bruce,
> Here is one way to achieve what you want above (and as Stavros says,
> this is not your original stated goal).
>
> mt(T):=block([TensorFactory],
>   TensorFactory:buildq([T:T],
>                        lambda([],T[val]:matrix([5,5],[5,5]),
>
> T[rank]:'Trank2UU,T)),apply(TensorFactory,[]))$
>
> The key here is that buildq lets you build a TensorFactory each
> time you call mt with a distinct symbol. Buildq substitutes in
> the symbol in place of T and voila, you have a custom-built
> anonymous function (that's the lambda) that takes no arguments.
> The final step applies that function to do the work.
>
> mt(X);
> ==> X
>
> X[val];
> ==> matrix([5,5],[5,5])
>
> If you want to see what TensorFactory produces, just remove the last
> step and have mt return TensorFactory.
>
> This business could be hidden from the user (you) by writing a custom
> macro, since the definition of mt can be mechanically constructed from
> the contents of lambda([],...).
>
> I imagine this is one of the motivations to use structures.
>
> Leo
>
> --
> The University of Edinburgh is a charitable body, registered in
> Scotland, with registration number SC005336.
>
>