# multiplication of infinity by zero in Matlab Calculation

28 views (last 30 days)

Show older comments

Hi,

I have a problem with the evaluation of an equation. My problem is that; one of the parts in the equation will result to infinity, and another part will result to zero. Then the product of them should give me zero BUT it gave me NAN. How I can solve this problem?

Thank you

##### 3 Comments

Roger Stafford
on 18 Mar 2017

### Accepted Answer

the cyclist
on 12 Feb 2014

Edited: the cyclist
on 12 Feb 2014

##### 10 Comments

Iain
on 24 Feb 2014

You'll need to work in log-space.

ln(exp(634)) = 634

ln(exp(-632.2)) = -632.2

634 + (-632.2) = 1.8

exp(1.8) = exp(634)*exp(-632.2)

I doubt that there is an automatic way to work in logarithms rather than normal numbers.

### More Answers (6)

Patrik Ek
on 12 Feb 2014

The solution to this problem comes from the mathematical limit. 1/0 = inf is really a bit sloppy. If you remember how this was introduced in the mathematical analysis course you most likely took for many years ago you would see that the correct way to work with infinities is to work with limits for example,

lim x->0 a/x = inf, a<inf equ(1)

This is however in most cases seen as a general theorem, which allows you to write 1/0 = inf. Another way to express a<inf is to say that a is bounded. Otherwise it is unbounded, it can take any value larger than the largest real value. The same applies for,

lim x->inf b/x = 0; b<inf, equ(2)

since x->inf can be anything is could be larger than 0.00... so this still applies. But what happens if we have an expression?

lim x->0 ax*1/bx = a/b*x/x = a/b, equ(3)

You see that x cancels out and the answer is a/b. So the limit of two undefined values a*inf and 1/(b*inf) actually depends on the speed with which they go towards their limit.

The problem is that when matlab becomes inf or zero, matlab can not say how fast they apporach the limit. The obvious solution to that problem is to say that the limit can not be set, or the limit does not exist. Matlab then returns a nan for the cases

inf/inf

0/0

0*inf

where equ(3) applies.

##### 0 Comments

Walter Roberson
on 24 Feb 2014

To make Matlab not consider exp(1000) to be infinity, overload the exp function for double datatype, and tell the function to return 42 instead of infinity when it detects that the absolute value of the argument exceeds realmax()

Good luck keeping from $%#@$'ing up other MATLAB code that expects infinity. Overloading a fundamental mathematical operation to make it lie is sure to be ... an interesting experience.

##### 0 Comments

David Young
on 23 Feb 2014

So x contains infinities and y contains zeros and we are willing to assume from knowledge of the earlier computation that when an infinity in x is multiplied by a zero in y, the correct answer is zero. Then it is reasonble to write:

z = x .* y;

z(isinf(x) & y == 0) = 0;

This replaces the NaNs that have been generated in this way by zeros.

##### 2 Comments

Walter Roberson
on 23 Feb 2014

Or more efficient,

z(y == 0) = 0;

If the inf might appear on either side,

z(~(x | y)) = 0;

Logan Capizzi
on 30 Nov 2021

If you want the NaN to be zero, you can do the following.

A(isnan(A)) = 0;

##### 0 Comments

Sri Vastava
on 25 Feb 2017

Edited: Walter Roberson
on 26 Feb 2017

the cyclist wrote: The product of 0 and infinity, mathematically, is not zero. It is indeterminate. That is why it gives you a NaN.

The answer is infinity.

##### 2 Comments

Walter Roberson
on 26 Feb 2017

David Goodmanson
on 26 Feb 2017

Edited: David Goodmanson
on 26 Feb 2017

Hello Sri, It really is indeterminate.

as x -> 0,

x -> 0 (of course)

x^2 -> 0

1/x is unbounded, -> inf

1/x^2 is unbounded, -> inf

now take three different expressions that are basically 0*inf:

as x-> 0

x^2 * (1/x) = x -> 0

x * (1/x^2) = 1/x is unbounded, -> inf

x * (6/x) = 6 -> 6

You can get any value that you want, so Matlab goes with the IEEE 754 standard and says NaN.

Andrea Barletta
on 16 Mar 2017

I don't fully agree with previous comments on the meaning of the product between 0 and infinity. It is true that the result of 0*Inf is indeterminate when the latter is interpreted as the product between two limits - it simply doesn't make any sense if it is interpreted as a standalone expression. But the limit of 0*f(x) will always give 0, no matter where x and f(x) are going. In such case, in Matlab, we should get a genuine 0*Inf=0. Neglecting this exception may cause some issues in programming. Suppose that I have a function f defined as a function g truncated over a compact set A. Mathematically, the value f(x) should be zero for every x outside A, no matter how g is defined. But as Jamal Ahmad more or less remarked in one comment if we take

f=@(x) exp(x).*(abs(x)<=10);

and we evaluate x=1e3 we incorrectly get f(1e3)=NaN. Of course, IF using anonymous functions is not a necessity, one may overcome the problem by defining f as

function y=f(x)

if abs(x)<10

y=exp(x);

else

y=0;

end

end

But apparently truncation and anonymous functions don't like each other in Matlab...

##### 9 Comments

Andrea Barletta
on 21 Jul 2017

Walter Roberson
on 22 Jul 2017

### See Also

### Categories

### Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!