{"id":167,"date":"2022-05-12T17:25:37","date_gmt":"2022-05-12T21:25:37","guid":{"rendered":"https:\/\/blogs.mathworks.com\/matlab\/?p=167"},"modified":"2022-05-19T11:00:49","modified_gmt":"2022-05-19T15:00:49","slug":"finding-if-all-elements-of-a-matrix-are-finite-fast","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/matlab\/2022\/05\/12\/finding-if-all-elements-of-a-matrix-are-finite-fast\/","title":{"rendered":"Finding if all elements of a matrix are finite, fast!"},"content":{"rendered":"
Today, I'm going to focus on three new functions that were added to the MATLAB programming language in R2022a: <\/span>allfinite<\/span><\/a>, <\/span>anynan<\/span><\/a> and <\/span>anymissing<\/span><\/a>. These functions are more concise, and usually faster, than alternative methods<\/span><\/div>
Are all matrix elements finite? Doing it the old way.<\/span><\/div>
How do you check if all the elements of a matrix are finite or not? Here's a matrix where the answer is 'No' by design.<\/span><\/div>
a=rand(3);a(2,2)=inf<\/span><\/span><\/div>
a = <\/span>3\u00d73<\/span><\/div><\/div>
0.6945 0.8625 0.0988\r\n 0.0722 Inf 0.7485\r\n 0.8283 0.2797 0.5190\r\n<\/div>
<\/div>
<\/div><\/div><\/div>
<\/div>
<\/div>
<\/div><\/div><\/div><\/div><\/div>
A common pattern for testing if <\/span>every<\/span> element in a matrix is finite is to first apply the <\/span>isfinite<\/span> function which returns a logical array:<\/span><\/div>
checkFinite = isfinite(a)<\/span><\/span><\/div>
checkFinite = <\/span>3\u00d73 logical array<\/span><\/div><\/div>
1 1 1\r\n 1 0 1\r\n 1 1 1\r\n<\/div>
<\/div>
<\/div><\/div><\/div>
<\/div>
<\/div>
<\/div><\/div><\/div><\/div><\/div>
and then pass this to the <\/span>all <\/span>function which checks if all the entries of each column are <\/span>true<\/span> or not<\/span><\/div>
checkAllRowsFinite = all(checkFinite)<\/span><\/span><\/div>
checkAllRowsFinite = <\/span>1\u00d73 logical array<\/span><\/div><\/div>
1 0 1\r\n<\/div>
<\/div>
<\/div><\/div><\/div>
<\/div>
<\/div>
<\/div><\/div><\/div><\/div><\/div>
we apply the <\/span>all<\/span> function one more time to get the result we want<\/span><\/div>
checkAllFinite = all(checkAllRowsFinite)<\/span><\/span><\/div>
checkAllFinite = logical<\/span><\/span><\/div>
0\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
No! All the entries of our original matrix are not finite! Usually, all of the above is put into one line:<\/span><\/div>
checkAllFinite = all(all(isfinite(a)))<\/span><\/span><\/div>
checkAllFinite = logical<\/span><\/span><\/div>
0\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
This was a common pattern for many years and things could get out of hand when dealing with multiple dimensional arrays. For example to check if every element of <\/span><\/div>
a=rand(3,3,3,3);<\/span><\/span><\/div><\/div><\/div>
is finite, we'd need to do<\/span><\/div>
checkAllFinite = all(all(all(all(isfinite(a)))))<\/span><\/span><\/div>
checkAllFinite = logical<\/span><\/span><\/div>
1\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
That's a lot of <\/span>all<\/span>! Some people use the concise but arguably cryptic<\/span><\/div>
checkAllFinite = all(isfinite(a(:)))<\/span><\/span><\/div>
checkAllFinite = logical<\/span><\/span><\/div>
1\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
So, in R2018b, we introduced a new way of doing this that's nicer to read<\/span><\/div>
checkAllFinite = all(isfinite(a),<\/span>'all'<\/span>)<\/span><\/span><\/div>
checkAllFinite = logical<\/span><\/span><\/div>
1\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
New in R2022a: allfinite - Finding if all is finite, fast<\/span><\/div>
We see these patterns a lot in both our code and user's code. So much so that in R2022a, we've developed another function to make it even easier to perform this common operation: <\/span>allfinite<\/span><\/div>
a = rand(3);a(2,2)=inf;<\/span><\/span><\/div><\/div>
CheckAllFinite = allfinite(a)<\/span><\/span><\/div>
CheckAllFinite = logical<\/span><\/span><\/div>
0\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
We didn't do this just to save on typing though. We did it because it's faster! You see the biggest difference with a large number of small matrices. Let's look at 10 million 3 x 3 matrices.<\/span><\/div>
a3 = rand(3);<\/span><\/span><\/div><\/div>
tic<\/span><\/span><\/div><\/div>
for <\/span>i =1:1e7<\/span><\/span><\/div><\/div>
tf = all(isfinite(a3), <\/span>'all'<\/span>);<\/span><\/span><\/div><\/div>
end <\/span><\/span><\/div><\/div>
oldMethodTime = toc<\/span><\/span><\/div>
oldMethodTime = 0.7560<\/div><\/div><\/div><\/div>
tic <\/span><\/span><\/div><\/div>
for <\/span>i =1:1e7<\/span><\/span><\/div><\/div>
tf = allfinite(a3);<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
newMethodTime=toc<\/span><\/span><\/div>
newMethodTime = 0.0847<\/div><\/div><\/div><\/div>
fprintf(<\/span>\"allfinite(a3) is %.2f times faster than all(isfinite(a3), 'all') for \" <\/span>+ <\/span>...<\/span><\/span><\/div><\/div>
<\/span>\"10 million small matrices\\n\"<\/span>,oldMethodTime\/newMethodTime)<\/span><\/span><\/div>
allfinite(a3) is 8.93 times faster than all(isfinite(a3), 'all') for 10 million small matrices<\/div><\/div><\/div><\/div><\/div>
That can add up to quite a difference in functions that are called a lot. The benefit is reduced for larger matrices but it's still useful<\/span><\/div>
a2000 = rand(2000);<\/span><\/span><\/div><\/div>
tic<\/span><\/span><\/div><\/div>
for <\/span>i =1:1e3<\/span><\/span><\/div><\/div>
tf = all(isfinite(a2000), <\/span>'all'<\/span>);<\/span><\/span><\/div><\/div>
end <\/span><\/span><\/div><\/div>
oldMethodTime = toc<\/span><\/span><\/div>
oldMethodTime = 2.9144<\/div><\/div><\/div><\/div>
tic <\/span><\/span><\/div><\/div>
for <\/span>i =1:1e3<\/span><\/span><\/div><\/div>
tf = allfinite(a2000);<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
newMethodTime=toc<\/span><\/span><\/div>
newMethodTime = 0.8977<\/div><\/div><\/div><\/div>
fprintf(<\/span>\"allfinite(a2000) is %.2f times faster than all(isfinite(a2000), 'all') for \" <\/span>+ <\/span>...<\/span><\/span><\/div><\/div>
<\/span>\"1000 large matrices\\n\"<\/span>,oldMethodTime\/newMethodTime)<\/span><\/span><\/div>
allfinite(a2000) is 3.25 times faster than all(isfinite(a2000), 'all') for 1000 large matrices<\/div><\/div><\/div><\/div><\/div>
Are there any NaNs or is anything missing?<\/span><\/div>
Along with <\/span>allfinite<\/span>, the MATLAB math team identified two other patterns that could be optimised in a similar way and came up with the functions <\/span>anynan<\/span><\/a> and <\/span>anymissing<\/span><\/a>. <\/span>When working with arrays, there will almost always be a speedup although you may have to run it many times to see it.<\/span><\/div>
B = 0.\/[-2 -1 0 1 2]<\/span><\/span><\/div>
B = <\/span>1\u00d75<\/span><\/div><\/div>
0 0 NaN 0 0\r\n<\/div>
<\/div>
<\/div><\/div><\/div>
<\/div>
<\/div>
<\/div><\/div><\/div><\/div>
tic<\/span><\/span><\/div><\/div>
repeats = 1e6;<\/span><\/span><\/div><\/div>
for <\/span>i =1:repeats<\/span><\/span><\/div><\/div>
tf = any(isnan(B), <\/span>'all'<\/span>);<\/span><\/span><\/div><\/div>
end <\/span><\/span><\/div><\/div>
oldMethodTime = toc<\/span><\/span><\/div>
oldMethodTime = 0.0887<\/div><\/div><\/div><\/div>
tic <\/span><\/span><\/div><\/div>
for <\/span>i =1:repeats<\/span><\/span><\/div><\/div>
tf = anynan(B);<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
newMethodTime=toc<\/span><\/span><\/div>
newMethodTime = 0.0126<\/div><\/div><\/div><\/div>
fprintf(<\/span>\"anynan(B) is %.2f times faster than any(isnan(B), 'all') for \" <\/span>+ <\/span>...<\/span><\/span><\/div><\/div>
<\/span>\"%d small vectors\\n\"<\/span>,oldMethodTime\/newMethodTime,repeats)<\/span><\/span><\/div>
anynan(B) is 7.03 times faster than any(isnan(B), 'all') for 1000000 small vectors<\/div><\/div><\/div><\/div><\/div>
Is anynan faster for all datatypes?<\/span><\/div>
For some data types, you might not see a speedup but it will be, at worst, as good as existing methods. Consider this example for checking for missing values in a table<\/span><\/div>
singleVar = single([1;3;5;7;9;11;13]);<\/span><\/span><\/div><\/div>
cellstrVar = {<\/span>'one'<\/span>;<\/span>'three'<\/span>;<\/span>''<\/span>;<\/span>'seven'<\/span>;<\/span>'nine'<\/span>;<\/span>'eleven'<\/span>;<\/span>'thirteen'<\/span>};<\/span><\/span><\/div><\/div>
categoryVar = categorical({<\/span>'red'<\/span>;<\/span>'yellow'<\/span>;<\/span>'blue'<\/span>;<\/span>'violet'<\/span>;<\/span>''<\/span>;<\/span>'ultraviolet'<\/span>;<\/span>'orange'<\/span>});<\/span><\/span><\/div><\/div>
dateVar = [datetime(2015,1:7,15)]';<\/span><\/span><\/div><\/div>
stringVar = [<\/span>\"a\"<\/span>;<\/span>\"b\"<\/span>;<\/span>\"c\"<\/span>;<\/span>\"d\"<\/span>;<\/span>\"e\"<\/span>;<\/span>\"f\"<\/span>;<\/span>\"g\"<\/span>];<\/span><\/span><\/div><\/div>
 <\/div><\/div>
mytable = table(singleVar,cellstrVar,categoryVar,dateVar,stringVar)<\/span><\/span><\/div>
mytable = <\/span>7\u00d75 table <\/span><\/div>
 <\/span><\/th>singleVar<\/span><\/th>cellstrVar<\/span><\/th>categoryVar<\/span><\/th>dateVar<\/span><\/th>stringVar<\/span><\/th><\/tr><\/thead>
1<\/span><\/th>1<\/span><\/td>'one'<\/span><\/td>red<\/span><\/td>15-Jan-2015<\/span><\/td>\"a\"<\/span><\/td><\/tr>
2<\/span><\/th>3<\/span><\/td>'three'<\/span><\/td>yellow<\/span><\/td>15-Feb-2015<\/span><\/td>\"b\"<\/span><\/td><\/tr>
3<\/span><\/th>5<\/span><\/td>''<\/span><\/td>blue<\/span><\/td>15-Mar-2015<\/span><\/td>\"c\"<\/span><\/td><\/tr>
4<\/span><\/th>7<\/span><\/td>'seven'<\/span><\/td>violet<\/span><\/td>15-Apr-2015<\/span><\/td>\"d\"<\/span><\/td><\/tr>
5<\/span><\/th>9<\/span><\/td>'nine'<\/span><\/td><undefined><\/span><\/td>15-May-2015<\/span><\/td>\"e\"<\/span><\/td><\/tr>
6<\/span><\/th>11<\/span><\/td>'eleven'<\/span><\/td>ultraviolet<\/span><\/td>15-Jun-2015<\/span><\/td>\"f\"<\/span><\/td><\/tr>
7<\/span><\/th>13<\/span><\/td>'thirteen'<\/span><\/td>orange<\/span><\/td>15-Jul-2015<\/span><\/td>\"g\"<\/span><\/td><\/tr><\/tbody><\/table><\/div><\/div>
<\/div>
<\/div>
<\/div><\/div><\/div><\/div><\/div>
Previously, you might have checked this as follows<\/span><\/div>
TF = any(ismissing(mytable),<\/span>'all'<\/span>)<\/span><\/span><\/div>
TF = logical<\/span><\/span><\/div>
1\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Now, we can do<\/span><\/div>
TF = anymissing(mytable)<\/span><\/span><\/div>
TF = logical<\/span><\/span><\/div>
1\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
The times are about the same so we can safely use these new functions all the time. Let's run it 5000 times to see<\/span><\/div>
tic<\/span><\/span><\/div><\/div>
repeats = 5e3;<\/span><\/span><\/div><\/div>
for <\/span>i =1:repeats<\/span><\/span><\/div><\/div>
tf = any(ismissing(mytable),<\/span>'all'<\/span>);<\/span><\/span><\/div><\/div>
end <\/span><\/span><\/div><\/div>
oldMethodTime = toc<\/span><\/span><\/div>
oldMethodTime = 0.4411<\/div><\/div><\/div><\/div>
tic <\/span><\/span><\/div><\/div>
for <\/span>i =1:repeats<\/span><\/span><\/div><\/div>
tf = anymissing(mytable);<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
newMethodTime=toc<\/span><\/span><\/div>
newMethodTime = 0.3786<\/div><\/div><\/div><\/div>

Updating MathWorks code to use these new functions<\/span><\/h3>
We've started using these new functions straight away in many MATLAB functions. They're used in argument validation in functions like expm, logm and median among others. Take a look for yourself by looking at the source code with, for example<\/span><\/div>
edit <\/span>sqrtm<\/span><\/span><\/div><\/div><\/div>

Over to you<\/span><\/h3>
In a release as big as R2022a that has many shiny features, simple functions such as these can often get overlooked. They are, however, useful new ways of performing very common operations. Teams at MathWorks are already starting to use them thoughout the codebase to make improvements here and there and I am sure I'll get the chance to usefully use them in user's code soon enough.<\/span><\/div>
Do you think they'll be useful in your workflow? Are there any similar functions you wish MATLAB had?<\/span><\/div>\r\n<\/div>