We must use a while loop to solve this problem (approximating the value of cos to within - or + 1-e10 ) and I believe I have all the right setup but I keep getting the error "missing value where TRUE/FALSE needed"
The question stating
A Taylor expansion of a function is an expression of the function as an infinite sum of terms. We can approximate the function by taking the first several terms of the infinite sum. The more terms we include, the better will be our approximation.
The Taylor expansion of the cosine function $cos(x)$ is: 1-((x^2)/(2!))+(x^4)/(4!)...
x = pi/2
n = 0
approximation = 1
limit = 1e-10
while(approximation < (limit*(-1)) || approximation > limit){
(term = c(((-1)^n)*((x)^(2*n)))/factorial(2*n))
(n = n + 1)
(approximation = approximation + term)
}
approximation
This is the code that I attempted but like I said it keeps giving me the error stated above.
To avoid this error, simply initialize n <- 1, which aligns your terms with the Taylor series.
When you initialize n <- 0, the series starts with 2 rather than 1, unlike the Taylor series. This causes approximation to converge wrongly on 1, by the 11th iteration.
x = pi/2
n = 0
approximation = 1
limit = 1e-10
while(approximation < (limit*(-1)) || approximation > limit){
(term = c(((-1)^n)*((x)^(2*n)))/factorial(2*n))
(n = n + 1)
(approximation = approximation + term)
# Debugging.
cat(sep = "\n",
sprintf("n = %3s; term = %22s; approximation = %17s", n, term, approximation)
)
}
approximation
As discussed below, this loops out of control until throwing an error.
n = 1; term = 1; approximation = 2 n = 2; term = -1.23370055013617; approximation = 0.76629944986383 n = 3; term = 0.253669507901048; approximation = 1.01996895776488 n = 4; term = -0.020863480763353; approximation = 0.999105477001525 n = 5; term = 0.000919260274839426; approximation = 1.00002473727636 n = 6; term = -2.52020423730606e-05; approximation = 0.999999535233992 n = 7; term = 4.71087477881817e-07; approximation = 1.00000000632147 n = 8; term = -6.38660308379185e-09; approximation = 0.999999999934866 n = 9; term = 6.56596311497947e-11; approximation = 1.00000000000053 n = 10; term = -5.29440020073462e-13; approximation = 0.999999999999996 n = 11; term = 3.4377391790986e-15; approximation = 1 n = 12; term = -1.83599165215524e-17; approximation = 1 # ... n = 85; term = 3.51311990046563e-270; approximation = 1 n = 86; term = -3.01715137758328e-274; approximation = 1 n = 87; term = 0; approximation = 1 n = 88; term = 0; approximation = 1 # ... n = 785; term = 0; approximation = 1 n = 786; term = 0; approximation = 1 n = 787; term = NaN; approximation = NaN Error in while (approximation < (limit * (-1)) || approximation > limit) { : missing value where TRUE/FALSE needed
But with n <- 1 we properly obtain an approximation of -6.51335680512735e-11, which terminates on the 7th iteration:
n = 2; term = -1.23370055013617; approximation = -0.23370055013617 n = 3; term = 0.253669507901048; approximation = 0.0199689577648782 n = 4; term = -0.020863480763353; approximation = -0.000894522998474732 n = 5; term = 0.000919260274839426; approximation = 2.47372763646945e-05 n = 6; term = -2.52020423730606e-05; approximation = -4.64766008366076e-07 n = 7; term = 4.71087477881817e-07; approximation = 6.32146951574058e-09 n = 8; term = -6.38660308379185e-09; approximation = -6.51335680512735e-11
As shown above, approximation converges on 1, and always remains greater than the limit of 1e-10. So the condition is always TRUE, and the while loop continues indefinitely.
# |------ TRUE -------|
while(approximation < (limit*(-1)) || approximation > limit){
# ...
}
But when n reaches 786, your term's numerator ((-1)^n)*((x)^(2*n)) maxes out at Infinity.
n <- 785
((-1)^n)*((x)^(2*n))
#> [1] -8.094815e+307
n <- 786
((-1)^n)*((x)^(2*n))
#> Inf
Now your denominator factorial(2*n) has been Inf for some time, ever since n reached 86.
n <- 85
factorial(2*n)
#> [1] 7.257416e+306
n <- 86
factorial(2*n)
#> [1] Inf
So until now, the overall quotient has been 0: a finite number divided by Infinity. But when n reaches 786, your term becomes Inf / Inf, which is NaN: "Not a Number".
n <- 785
c(((-1)^n)*((x)^(2*n)))/factorial(2*n)
#> [1] 0
-8.094815e+307 / Inf
#> [1] 0
n <- 786
c(((-1)^n)*((x)^(2*n)))/factorial(2*n)
#> [1] NaN
Inf / Inf
#> [1] NaN
When approximation is incremented by NaN, the result is still NaN.
1 + NaN
#> [1] NaN
With an approximation of NaN, your while conditions evaluate to NA: "Not Available".
limit <- 1e-10
NaN < (limit*(-1))
#> [1] NA
NaN > limit
#> [1] NA
NA || NA
#> [1] NA
In your while loop, this NA condition throws the error you encountered.
while(NA){
# ...
}
#> Error in while (NA) { : missing value where TRUE/FALSE needed