MathGroup Archive 2005

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

Search the Archive

Re: Types in Mathematica, a practical example

  • To: mathgroup at
  • Subject: [mg62816] Re: [mg62800] Types in Mathematica, a practical example
  • From: Sseziwa Mukasa <mukasa at>
  • Date: Tue, 6 Dec 2005 00:03:12 -0500 (EST)
  • References: <>
  • Sender: owner-wri-mathgroup at

On Dec 5, 2005, at 1:41 PM, Ingolf Dahl wrote:

> To MathGroup,
> I am not an advocate for strong typing in Mathematica, but consider  
> the
> following simple example: I want to see if two matrices are equal.  
> One of
> them was the result from some equation, and is given inside a rule.  
> Then I
> write some code similar to this:
> a = {{1, 2}, {3, 4}};
> x - a /. {x -> a}
> I of course hope to get a matrix filled by zeroes, but if x is  
> undefined,
> the following is returned:
> {{{{0, 1}, {2, 3}}, {{-1, 0}, {1, 2}}}, {{{-2, -1}, {0, 1}}, {{-3,  
> -2}, {-1,
> 0}}}}
> First x was assumed to be a number, and (x - a) was evaluated.

x was not assumed to be a number, x is a Symbol and without any  
definitions for x, x-a is {{-1 + x, -2 + x}, {-3 + x, -4 + x}} as  

> Then x was
> substituted by the matrix a.

Actually first 1 is substituted for x then 2 etc.  The result is what  
happens when you evaluate the expression for x-a above for each of  
those values of x.

> is there any
> reasonably simple way to "type" x to be a list of lists without  
> specifying
> the elements, in such a way that the above example works?

The unbound symbol x has a value (x) and given the rules for Subtract  
and lists and the value of a the rest of the results follow.  If you  
want to treat x as having some other value (such as a list of lists)  
you have to assign that value to it, since the values of the elements  
in your case are unimportant(although in this case they actually are  
as you say below) then

x=Table[y, Evaluate[Sequence @@ Transpose[{Dimensions[a]}]]]

should suffice, but this is an unwieldy structure to work with,  
especially for the problem at hand.

> I remember that I as a newbie looked for ways to declare
> matrices, in such a way that I later could specify matrix elements
> one-by-one, without initializing them first.

Define expressions which returns the desired values when x is  
supplied with arguments:

x[a_,b_] := a[[a,b]]

  in this case.  The problem is then you have to cognizant of what x  
in x-a means because of the rules around lists.

> if x in some way is declared to be a 2x2 list of lists:
> {{x[[1,1]] - 1, x[[1,2]] - 2},{x[[2,1]] - 3, x[[2,2]] - 4}}

This specification makes clear that you are actually interested in  
the values of the elements of x, they are supposed to be equivalent  
to some unspecified matrix.


is such a structure and you can use appropriate substitutions for y 
[i,j].  This is not an easy exercise because if a is larger than 2x2  
there's a lot of bookkeeping to do, and you have to remember to leave  
y defined as a Symbol.  This is also using the facilities of  
Mathematica in a rather perverse way, it is possible.  As always  
until the advent of natural language understanding AIs with reasoning  
ability programming will remain a task of clearly specifying what is  
meant and expressing it unambiguously.

> I am not allowed to Unset or Clear any part of a list either. Why not?

What would clearing part of a list mean?  Similarly for Unset.  If  
you have a good idea of what such an expression should evaluate to  
you can use UpValues and Unprotect to make it happen.



  • Prev by Date: Re: Types in Mathematica, a practical example
  • Next by Date: Re: Re: A question about algebraic numbers using Mathematica
  • Previous by thread: Re: Types in Mathematica, a practical example
  • Next by thread: Re: Types in Mathematica, a practical example