Question

(Factorial) The factorial of a nonnegative integer \(n\) is written \(n !\) (pronounced "n factorial") and is defined as follows: \(n !=n \cdot(n-1) \cdot(n-2) \cdot \ldots \cdot 1 \quad(\text { for values of } n \text { greater than } 1)\) and \\[ n !=1 \quad(\text { for } n=0 \text { or } n=1) \\] For example, \(5 !=5 \cdot 4 \cdot 3 \cdot 2 \cdot 1,\) which is \(120 .\) Use while statements in each of the following: a) Write a program that reads a nonnegative integer and computes and prints its factorial. b) Write a program that estimates the value of the mathematical constant \(e\) by using the formula: \\[ e=1+\frac{1}{1 !}+\frac{1}{2 !}+\frac{1}{3 !}+\ldots \\] Prompt the user for the desired accuracy of \(e\) (i.e., the number of terms in the summation) c) Write a program that computes the value of \(e^{x}\) by using the formula \\[ e^{x}=1+\frac{x}{1 !}+\frac{x^{2}}{2 !}+\frac{x^{3}}{3 !}+\ldots \\] Prompt the user for the desired accuracy of \(e\) (i.e., the number of terms in the summation).

Short answer

For (a), implement a while loop to compute the factorial of an integer. For (b), compute e using the formula in a loop with factorial calculations. For (c), adapt the loop from (b) to include powers of x for computing e^x.

Step-by-step solution

Solution for Part (a) - Factorial Program

To write a program to compute the factorial of a nonnegative integer:1. Prompt the user to enter a nonnegative integer.2. Initialize a variable, say factorial, to 1.3. Use a while loop that runs from the number down to 2 and multiply factorial by the loop variable in each iteration.4. After the loop ends, print the factorial value.

Solution for Part (b) - Computing Mathematical Constant e

To estimate the value of the mathematical constant e:1. Prompt the user for the number of terms for the desired accuracy of e.2. Initialize e to 1 since the first term of the summation is 1.3. Use a while loop to iterate over the range from 1 to the number of terms minus one. In each iteration:a. Compute the factorial of the loop variable.b. Add the reciprocal of the factorial to e.4. Print the value of e after the iterations.

Solution for Part (c) - Computing e^x

To compute the value of e raised to the power x:1. Prompt the user for the value of x and the number of terms for the desired accuracy of e^x.2. Initialize e_pow_x to 1, as the first term of the series is 1.3. Also, initialize numerator to x, as it represents x raised to the power of the current term (starting with x^1 for the second term).4. Use a while loop to iterate over the range from 1 to the number of terms minus one. In each iteration:a. Compute the factorial of the loop variable.b. Add the division of the numerator by the factorial to e_pow_x.c. Multiply numerator by x for the next term power.5. Print the computed value of e_pow_x.

Key concepts

C++ loops

Loop structures are fundamental in programming, allowing us to repeat a block of code multiple times without having to write the same code over and over again. The C++ language offers several loop constructs, including the 'while', 'for', and 'do-while' loops. In the context of computing factorials, a 'while' loop is particularly helpful because it keeps executing its instructions as long as the condition it checks remains true.

In the case of calculating a factorial, where we multiply a series of descending integers, a 'while' loop can iterate backwards from the number down to 1. Our stopping condition is that we keep going until we hit 1, the point where we've incorporated all necessary factors. This type of loop provides a clear and concise way to handle the repetitive task of factorial multiplication.

When using loops in C++, careful consideration should be given to initializing variables correctly and ensuring that the loop updates these variables as intended. Infinite loops, where the stopping condition is never met, are a common pitfall that should be actively prevented during the coding process.

Computing Mathematical Constants

Mathematical constants like \(e\), the base of natural logarighms, are fundamental in various fields of science and mathematics. Accurately computing these constants often requires methods that can approximate their values to a desired level of precision. One approach utilizes the concept of a limit as defined by an infinite series.

To estimate \(e\), we can use a series expansion where the constant is expressed as the sum of reciprocals of factorials. Calculating \(e\) to a particular accuracy involves summing enough terms in the series until the incremental change becomes negligible relative to the desired precision.

This process of computing \(e\) calls for both loops, to sum the terms, and an understanding of factorial calculation, since each term of the series includes a factorial. By using a 'while' loop, we can continually add terms until we achieve the accuracy requested by the user. Since each added term reduces in size due to the growth of the factorial in the denominator, the series converges, allowing us to calculate an approximate value of \(e\) with a finite number of terms.

Power Series Expansion

Power series are used in mathematics to represent functions as an infinite sum of terms. Each term of the power series is a multiple of a power of a variable, typically denoted as \(x\), divided by a factorial. The series expansion of \(e^{x}\) is a classic example of such use, where the exponential function is represented as an infinite series.

The power series for \(e^{x}\) consists of terms \(x^{n} / n!\) with \(n\) starting from 0 to infinity. Computing \(e^{x}\) is similar to computing \(e\) but involves the additional step of multiplying by \(x^{n}\). Here, the factorial decreases the value of each successive term, despite the increasing power of \(x\), leading to convergence of the series.

For practical purposes, such as in a program, we truncate the series after a certain number of terms, which we determine based on the desired precision. In C++, this truncation can be achieved using a 'while' loop, where we calculate each term of the series and add it to a running total until we reach our approximation threshold.