MATLAB: Problem using factorial in matlab

factorials

I wanted to calculate 200! but after 170! matlab starts showing result NaN. So is there any way possible to calculate this number using matlab???

Best Answer

You cannot solve it with a double precision result, because it will overflow the dynamic range of a double.

factorial(200)
ans =
   Inf

But if you are willing to use other tools, there is no problem. For example, the symbolic toolbox gives you this:

factorial(sym(200))
ans =
788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000

Or, my own vpi toolbox , found on the file exchange:

factorial(vpi(200))
ans =
  78865786736479050355236321393218506229513597768717326329474253324435
944996340334292030428401198462390417721213891963883025764279024263710506
192662495282993111346285727076331723739698894392244562145166424025403329
186413122742829485327752424240757390324032125740557956866022603190417032
406235170085879617892222278962370389737472000000000000000000000000000000
0000000000000000000

In either case, the result is an integer with almost 400 digits.

If you are happy with a floating point number, use my HPF toolbox . So in 50 digits of precision...

factorial(hpf(200,50))
ans =
7.8865786736479050355236321393218506229513597768717e374

Remember that any such high precision computation will be far less efficient than using a double. You are almost always better off using good numerical methods to avoid the problem in the first place. But that is why they teach entire courses about such methods, and books are written on the topic.

Related Solutions

MATLAB: How to decrease precision

You cannot tell MATLAB to use an arbitrary lower or higher precision. At most, you can work in single precision instead of double. But even there, you need to be careful, as all numbers by default are ALWAYS doubles. So it would be possible to introduce doubles into the problem, thus to accidentally suddenly start working in double precision. Luckily, singles tend to propagate.

A = single(2) + double(3)
A =
  single
     5

Can you do more than that? This is difficult if you choose to force yourself to work with the standard MATLAB numeric data types. I suppose you could download my HPF toolbox from the file exchange. So, in HPF, if I want to force all computations done in that tool to use EXACTLY 7 decimal digits, then I could do this:

DefaultNumberOfDigits 7 0
x = hpf(pi)
x =
3.141593

That will cause all numbers created as HPF to display and store only 7 digits, with no hidden (i.e., guard) digits carried in the background, and that setting will persist until you change it, even if you exit MATLAB and restart.

https://www.mathworks.com/matlabcentral/fileexchange/36534-hpf-a-big-decimal-class

And, of course, you can also work with the symbolic toolbox.

MATLAB: How to use large numbers

Depending on what you are doing, you can use any of several tools. For example ...

The symbolic toolbox:

sym(17)^173
ans =
737332536277664007345135166862919042342198303176957733423911897658606050420746608682751241168475893711891774173437592993636785506777793476094874734220957516554685643214228598246375959317220176420842802110495459537

My own VPI toolbox (free download from the file exchange):

vpi(17)^173
ans =
    73733253627766400734513516686291904234219830317695773342391189765860
605042074660868275124116847589371189177417343759299363678550677779347609
487473422095751655468564321422859824637595931722017642084280211049545953
7

Of course, VPI is only for large integer arithmetic.

For high precision floating point operations, you can use my HPF toolbox, also a free download from the file exchange. So here, the sine of 2.3 radians, out to 500 decimal digits.

DefaultNumberOfDigits 500
sin(hpf('2.3'))
ans =
0.74570521217672017738540621164349953894264877802047425750762828050000099313904725787119141718409288762817250225753133592135334980555453298342113583580957089845003916537428359514540258159501067012614643093890466791278548509412263198294482089203977890584979559621160856653150662947581690813330676541668856555926001056589318039296179001073304389700504217567754815087240130585632142045686943253384330660013244550634516301559995926758472414911946682819947915408675727440373168283432224358384420096808300220

Again, the symbolic toolbox can also give you large number arithmetic for floats.

digits 500
sin(sym('2.3'))
ans =
0.7457052121767201773854062116434995389426487780204742575076282805000009931390472578711914171840928876281725022575313359213533498055545329834211358358095708984500391653742835951454025815950106701261464309389046679127854850941226319829448208920397789058497955962116085665315066294758169081333067654166885655592600105658931803929617900107330438970050421756775481508724013058563214204568694325338433066001324455063451630155999592675847241491194668281994791540867572744037316828343222435838442009680830022

HOWEVER, a large, even huge caveat exists. Much of the time, you never needed to use those large numbers in the first place! This often means you need to learn to use mathematics in a thoughtful way.

For example, at least some of the time when we think we need to use large integer arithmetic, we can avoid it completely. Thus, what is the value of mod(2^2000,17)?

mod(2^2000,17)
ans =
   NaN

Of course that fails, since 2^2000 overflows a double, creating an inf. The mod of that is indeterminate, so the mod is a NaN.

However, we can use powermod toools (I have one in my VPI toolbox, and there is one in the symbolic toolbox too.)

powermod(2,2000,17)
ans =
     1

As you can see, it is correct.

mod(sym(2)^2000,17)
ans =
1

Powermod tools are tremendously useful for large integer problems, doing things like primality testing and large integer factorizations.

For example, suppose I want to compute a Taylor series expansion for exp(x). That series looks like:

exp(x) = 1 + x + x^2/factorial(2) + x^3/factorial(3) + x^4/factorial(4) + x^5/factorial(5) + ...

A good trick for many series is to recognize that one term of the series can easily be computed from the previoius term. Think about it. How would you compute the term

x^(n+1)/factorial(n+1)

if you already know the term

x^n/factorial(n)

And of course, logs are often valuable too, if you recognize that factorial(n) = gamma(n+1), and you know that the gammaln function exists, and does not need to compute a factorial at all.

log(factorial(100))
ans =
       363.74
       
gammaln(101)
ans =
       363.74

The point is, very often, use of mathematics in an intelligent, artful way is far better than a brute force use of arithmetic.

Best Answer

Related Solutions

MATLAB: How to decrease precision

MATLAB: How to use large numbers

Related Question