[R] combining mathematical notation and value substitution

[Uwe Ligges]

Faheem Mitha wrote:
> 
>>>"Monotonic Multigamma run (" * n  == len * ", " * theta == t1 *
>>>
>>>Is this a valid expression? My understanding of an expression is that it
>>>contains one more more statements.
>>
>>That's only part  of the expression. This is the full expression
>>"Monotonic Multigamma run (" * n  == len * ", " *  theta == t1 * ")."
>>
>>Now, this looks very strange, but if it looked like
>>   a* n==len * b * theta==t1 * d
>>it would be a perfectly reasonable  product of five terms,  two of which
>>are logical expressions.  I think in fact that it is a call, not an
>>expression, but in this case it doesn't matter.

Yes, thanks.


>>In Uwe's example a, b, and d were strings.  The expression is still
>>lexically valid, but it can't be evaluated any more. That's ok, since it
>>isn't supposed to be evaluated.

Yes. A very important statement. for mathematical annotation it's just 
parsed in a way. And it's a natural way to use an expression when doing 
*mathematical* annotation.


> So multiplication is lexically valid in R even between logical
> expression and strings?

Yes. See Section 6.2 od the R Language Reference.
Consider you introduce a method for a certain new class, that handles 
for any imaginary reason multiplication of logicals and characters. So 
you don't want R to forbid it when constructing an expression or call.


> The * really corresponded to multiplication, then?  Hmm. I see the
> choice of * was so that it would not appear in the final math
> expression produced by title. Ingenious.

 From ?plotmath: "x*y  juxtapose x and y".

BTW: "Ingenious" from those who introduced mathematical annotation in R:
Paul Murrell and Ross Ihaka (2000). An Approach to Providing 
Mathematical Annotation in Plots, Journal of Computational and Graphical 
Statistics, 9(3): 582–599.


>>What you can use in the mathematical annotation functions is parsed but
>>unevaluated R code.  You can get this mostly easily as the output of
>>quote(), expression() or substitute().
>>
>>  quote("Parameter " * theta==1)
>>  expression("Parameter " * theta==1)
>>  substitute("Parameter " * theta==t, list(t=1))
>>
>>For the purposes of mathematical annotation these are all equivalent,
>>though the second returns an `expression' and the other two return a
>>`call'.
>>
>>The second form is occasionally needed, as in
>>  legend(locator(1), lty=1:2, legend=expression(alpha,beta))
>>which I don't think you can do any other way.

In the reference given in my former mail their is an example how to 
construct such an expression from calls (constructed by substitute()) 
for legend() with do.call().


>>You can think of an expression as a vector of calls, so
>>
>>>expression(alpha,beta)[1]
>>
>>expression(alpha)
> 
> 
> This is an expression (according to ?expression).
> 
> 
>>>expression(alpha,beta)[[1]]
>>
>>alpha
> 
> 
> This is a call.
> 
> Can you go into a little more detail here about why alpha here is a
> call?  

Thomas already told it and ?expression says as well: "expression returns 
a vector of mode "expression" containing its arguments as unevaluated 
``calls''."


 > I'm not terribly clear what a call is. If it so similar to an
> expression, what distinguishes it from an expression, and why do we
> need two similar concepts like this?

Obviously a question for Bill Venables. I admit I've not thought about 
it before. In this context the article
  W. N. Venables (2002). Programmer’s Niche, R News, 2(2): 24–26,
  ISSN 1609-3631, http://CRAN. R-project.org/doc/Rnews/,
and
  Venables & Ripley (2000): S Programming, Springer.
are nice references.

Uwe Ligges

> Also, would it not be more accurate to describe an expression as a
> list of calls? Since, the [[ ]] applied to a list returns a component
> of that list, which in this case is apparently a call.
> 
> 
>>which is what the manual was trying to say (I think). Much of the time
>>you can ignore the difference between `call' and `expression' objects.
> 
>                                                         Faheem.