# index - matlab replacing values in a matrix

## How can I index a MATLAB array returned by a function without first assigning it to a local variable? (6)

For example, if I want to read the middle value from `magic(5)`

, I can do so like this:

```
M = magic(5);
value = M(3,3);
```

to get `value == 13`

. I'd like to be able to do something like one of these:

```
value = magic(5)(3,3);
value = (magic(5))(3,3);
```

to dispense with the intermediate variable. However, MATLAB complains about `Unbalanced or unexpected parenthesis or bracket`

on the first parenthesis before the `3`

.

Is it possible to read values from an array/matrix without first assigning it to a variable?

At least in MATLAB 2013a you can use `getfield`

like:

```
a=rand(5);
getfield(a,{1,2}) % etc
```

to get the element at (1,2)

How do you feel about using undocumented features:

```
>> builtin('_paren', magic(5), 3, 3) %# M(3,3)
ans =
13
```

or for cell arrays:

```
>> builtin('_brace', num2cell(magic(5)), 3, 3) %# C{3,3}
ans =
13
```

Just like magic :)

## UPDATE:

Bad news, the above hack doesn't work anymore in **R2015b**! That's fine, it was undocumented functionality and we cannot rely on it as a supported feature :)

For those wondering where to find this type of thing, look in the folder `fullfile(matlabroot,'bin','registry')`

. There's a bunch of XML files there that list all kinds of goodies. Be warned that calling some of these functions directly can easily crash your MATLAB session.

It could be more simple if you make a new function:

```
function [ element ] = getElem( matrix, index1, index2 )
element = matrix(index1, index2);
end
```

and then use it:

```
value = getElem(magic(5), 3, 3);
```

Note that if you compare running times with the standard way (asign the result and then access entries), they are exactly the same.

```
[email protected](M,i,j) M(i,j);
>> for nit=1:10;tic;subs(magic(100),1:10,1:10);tlap(nit)=toc;end;mean(tlap)
ans =
0.0103
>> for nit=1:10,tic;M=magic(100); M(1:10,1:10);tlap(nit)=toc;end;mean(tlap)
ans =
0.0101
```

To my opinion, the bottom line is : MATLAB does not have pointers, you have to live with it.

To complement Amro's answer, you can use `feval`

instead of `builtin`

. There is no difference, really, unless you try to overload the operator function:

BUILTIN(...) is the same as FEVAL(...) except that it will call the original built-in version of the function even if an overloaded one exists (for this to work, you must never overload BUILTIN).

```
>> feval('_paren', magic(5), 3, 3) % M(3,3)
ans =
13
>> feval('_brace', num2cell(magic(5)), 3, 3) % C{3,3}
ans =
13
```

What's interesting is that `feval`

seems to be just a tiny bit quicker than `builtin`

(by ~3.5%), at least in Matlab 2013b, which is weird given that `feval`

needs to check if the function is overloaded, unlike `builtin`

:

```
>> tic; for i=1:1e6, feval('_paren', magic(5), 3, 3); end; toc;
Elapsed time is 49.904117 seconds.
>> tic; for i=1:1e6, builtin('_paren', magic(5), 3, 3); end; toc;
Elapsed time is 51.485339 seconds.
```

Your initial notation is the most concise way to do this:

```
M = magic(5); %create
value = M(3,3); % extract useful data
clear M; %free memory
```

If you are doing this in a loop you can just reassign M every time and ignore the clear statement as well.