Dynamic on the fly expression/function

Hello,

I want to create a mathematical expression like this. It has certain pattern as given below and number of terms in the expression depends on my input 'i'

given input i=2, matrix T and constant 'c' then some matrix variable T_dot is given by

T_dot = T(c)-T(c-2)...
      + T(c+(8*9^0))- T(c+(8*9^0 - 2*9^1)) 

if i=3, then

T_dot = T(c)-T(c-2)...
      + T(c+(8*9^0))- T(c+(8*9^0 - 2*9^1))...
      + T(c+(8*9^0)+(8*9^1))- T(c+(((8*9^0)+(8*9^1) - 2*9^2))

if i=4, then

T_dot = T(c)-T(c-2)...
      + T(c+(8*9^0))- T(c+(8*9^0 - 2*9^1))...
      + T(c+(8*9^0)+(8*9^1))- T(c+(((8*9^0)+(8*9^1) - 2*9^2))...
      + T(c+(8*9^0)+(8*9^1)+(8*9^2))- T(c+(((8*9^0)+(8*9^1)+(8*9^2) - 2*9^3))
  

and so on.... Clearly you can see a pattern in above terms. Basically I have pattern in indices of matrices, but I also want to have these expressions, because later I use T_dot as starting point for 'for loop'. How can I create this? Should I be creating this as a string? or is there any simple way?

Thank you

[Stephen23]

" How can I create this?"

Probably using vectorization and/or loops and/or recursion.

"Should I be creating this as a string?"

NO!

If you are able to generate this as a string, then it is also possible to generate it directly as operations on numeric input arguments. Using eval on a string just adds an extra inefficient layer of complexity.

"... is there any simple way?"

Loops and vectorization are simple... recursion a little less so, but still doable.

Could you please clarify a few things:

1- for completeness please provide the output for i=1.

2- mismatching parentheses around the last term of i=3 please confirm:

T(c+(((8*9^0)+(8*9^1) - 2*9^2)))
%                              ^ missing ?

3- mismatching parentheses around the last term of i=4 please confirm:

T(c+(((8*9^0)+(8*9^1)+(8*9^2) - 2*9^3)))
%                                      ^ missing?

4- You write that the output is "...some matrix variable T_dot ...", but all of the indexing into T appears to be scalar, which means that T_dot would also be scalar. What do you mean that T_dot is a "matrix variable", when your own examples show that it is scalar?

It is an interesting task, if you have some patience I will look at it now...

[Sandeep Parameshwara]

1. For i=1

T_dot = T(c)-T(c-2)

2. Yes, you are right. Parantheses is missing

3. Yes, you are right. Parantheses is missing, sorry.

[Sandeep Parameshwara]

4. I simplifed the indexing whe I posed the question. It is actually like this, for example for i=2,

T_dot(:,:,1) = T(:,:,c)-T(:,:,c-2)...
      + T(:,:,c+(8*9^0))- T(:,:,c+(8*9^0 - 2*9^1))
  

For i=3,

  T_dot(:,:,1) = T(:,:,c)-T(:,:,c-2)...
      + T(:,:,c+(8*9^0))- T(:,:,c+(8*9^0 - 2*9^1))...
      + T(:,:,c+(8*9^0)+(8*9^1))- T(:,:,c+(((8*9^0)+(8*9^1) - 2*9^2)))

I am considering all rows and columns and would like to vary only the third index

Answer 1

[Stephen23]

Vector Indices: You can do this quite easily by generating vectors of indices and taking advantage of the fact that addition and subtraction are commutative**. For example:

>> i = 4;
>> c = 4321;
>> X = cumsum([0,8*9.^(0:i-2)]); % explanation below
>> Y = 2*9.^(0:i-1);             % explanation below
>> T = rand(1,1e4); % random data matrix
>> sum(T(c+X)-T(c+X-Y))
ans = 0.736941330376921

And now compare against your method (you can see the 15th digit is different, see ** below):

>> T(c) - T(c-2) + T(c+(8*9^0)) - T(c+(8*9^0 - 2*9^1)) + T(c+(8*9^0)+(8*9^1)) - T(c+(((8*9^0)+(8*9^1) - 2*9^2))) + T(c+(8*9^0)+(8*9^1)+(8*9^2)) - T(c+(((8*9^0)+(8*9^1)+(8*9^2) - 2*9^3)))
ans = 0.736941330376922

How it works: For each susbsequent i value you add new terms, but do not change the existing terms. Lets rearrange your i=4 example so that the terms are aligned in columns:

 T(c)                         - T(c                           - 2) +           % same as i=1
 T(c+(8*9^0))                 - T(c+(8*9^0                    - 2*9^1)) +      % same as i=2
 T(c+(8*9^0)+(8*9^1))         - T(c+(((8*9^0)+(8*9^1)         - 2*9^2))) +     % same as i=3
 T(c+(8*9^0)+(8*9^1)+(8*9^2)) - T(c+(((8*9^0)+(8*9^1)+(8*9^2) - 2*9^3)))       % new for i=4
%T(c+X)                       - T(c+X                         - Y) % equivalent in my code

The Y term is simpler, so lets start with that: it contains the values

Y = [2, 2*9^1, 2*9^2, 2*9^3]

which is just

Y = 2*9.^(0:i-1)

We can see that the X term is used twice and also involves some kind of cummulative sum. It contains the values

X = [0, 8*9^0, 8*9^0+8*9^1, 8*9^0+8*9^1+8*9^2]

and we notice that each term repeats the previous one plus something new. That new part is just

[0, 8*9^0, 8*9^1, 8*9^2]

which is just

[0,8*9.^(0:i-2)]

and then use cumsum to get the final X vector:

X = cumsum([0,8*9.^(0:i-2)])

The rest is just indexing and addition.

** For numeric computation on binary floating point numbers addition/subtraction are not always commutative, as the results shown above demonstrate. But within reasonable precision we can hold it as being true... as you would anyway not be performing such operations on binary floating point numbers and expecting exact results.

[Sandeep Parameshwara]

Thanks a lot for your help!

Answer 2

[Githin John]

I am assuming that when you say you want to have the expressions for later use, you mean you want to store the indices as an expression. I would suggest using a cell array containing strings. Something like this.

T_dot_exp = {'T(c)' '-T(c-2)'...
       'T(c+(8*9^0))' '-T(c+(8*9^0 - 2*9^1))'...
      'T(c+(8*9^0)+(8*9^1))' '-T(c+(((8*9^0)+(8*9^1) - 2*9^2))'...
      'T(c+(8*9^0)+(8*9^1)+(8*9^2))' '-T(c+(((8*9^0)+(8*9^1)+(8*9^2) - 2*9^3))'}
  

or just the indices alone:

T_dot_exp = {'(c)' '(c-2)'...
       '(c+(8*9^0))' '(c+(8*9^0 - 2*9^1))'...
      '(c+(8*9^0)+(8*9^1))' '(c+(((8*9^0)+(8*9^1) - 2*9^2))'...
      '(c+(8*9^0)+(8*9^1)+(8*9^2))' '(c+(((8*9^0)+(8*9^1)+(8*9^2) - 2*9^3))'}
  

To use the value of the first expressions you may try

      eval(T_dot_exp{1})

Edit: Thank you for pointing out the problems with my suggestions. I read up on your write-up and the MATLAB docs about misuse of eval. Enlightened.