How can I write this function for the variable "n"? Assuming that I already specified the value of the constant theta.
MATLAB: How to create this function on MATLAB
MATLABmatlab functionsum
Related Solutions
If you are not careful, you will need to use a tool with literally thusands of digits of precision, as those terms will vary by thousands of digits in magnitude. Worse, if you even try to compute any of those terms, you will find that double precision either underflows or overflows.
vpa(factorial(sym(1247)))ans =8.458643820551953682887859707083e+3320
As such, in order to compute that series, you will need to use symbolic computations, or use a tool like my HPF. I'll do it using HPF, although I could have as easily used the symbolc toolbox too.
DefaultNumberOfDigits 100S = hpf(0);E = exp(hpf(-1211.5));T = hpf(1);for n = 0:1247 S = S + E*T; T = T*1211.5/(n+1);endSS =0.8494300028975462166085239594512340095256328874564113849900813900015574782646329472378321829350836040
That is the lazy way to solve the problem. It involves no real effort, no thought about how to compute the result.
Can you solve the problem using double precision? Well yes. But again, you MUST be careful. And you must understand how to work with double precision in a way that does not underflow or overflow before you have gotten the result you need. The trick is often to use logs on these problems.
S = 0;T = -1211.5;for n = 0:1247 S = S + exp(T); T = T + log(1211.5) - log(n+1);endSS = 0.849430002892729
In this sum, you should realize that almost every single term is effectively zero. So by using natural logs, I computed the log of every term, then exponentiate only after I have computed the log of the complete term.
As you should see, the two computations agree reasonably well. The double precision term is wrong in the last few digits, but you also need ot consider that every term in that series varies by as much as roughly 3 decimal digits. So that is probably as good as I can easily do using doubles.
Depending on what you are doing, you can use any of several tools. For example ...
The symbolic toolbox:
sym(17)^173ans =737332536277664007345135166862919042342198303176957733423911897658606050420746608682751241168475893711891774173437592993636785506777793476094874734220957516554685643214228598246375959317220176420842802110495459537
My own VPI toolbox (free download from the file exchange):
vpi(17)^173ans = 737332536277664007345135166862919042342198303176957733423911897658606050420746608682751241168475893711891774173437592993636785506777793476094874734220957516554685643214228598246375959317220176420842802110495459537
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 500sin(hpf('2.3'))ans =0.74570521217672017738540621164349953894264877802047425750762828050000099313904725787119141718409288762817250225753133592135334980555453298342113583580957089845003916537428359514540258159501067012614643093890466791278548509412263198294482089203977890584979559621160856653150662947581690813330676541668856555926001056589318039296179001073304389700504217567754815087240130585632142045686943253384330660013244550634516301559995926758472414911946682819947915408675727440373168283432224358384420096808300220
Again, the symbolic toolbox can also give you large number arithmetic for floats.
digits 500sin(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