Write a modular C++ program to generate user-specified subsequence fragments demonstrating linear, polynomial, and exponential rates of growth, as specified below.

Overview

1. On startup, the program offers the following menu.

     Please specify the type of sequence you wish to examine.
             a  ---  Arithmetic (linear)
             p  ---  Polynomial (specify degree)
             g  ---  Geometric  (exponential)
     Enter 'q' to quit or 'h' to display this menu again.
     apgqh>
     

   After generating and displaying a sequence fragment and its sum, the program displays the simple prompt apgqh>. Iterations continue in this fashion until the user quits.

2. If the user selects a (linear growth rate), the program prompts for
   1. the first element in the sequence
   2. the difference between successive elements: d = s_i+1 - s_i.
   3. the number of elements to generate, i.e., the "fragment length" (Recall that in this type of sequence, d is constant, independent of i.)

3. For polynomial growth, it is sufficient and customary to consider only monomials, i.e., expressions of the form c xⁿ for integers n > 1 and constants c > 0. If the user selects p, the program prompts for
   1. the degree n of the monomial
   2. the value of the positive constant c
   3. the initial value of the base x
   4. the base increment, i.e., the constant difference d between successive values of the base x
   5. the number of elements to generate, i.e., the "fragment length"

4. Processing of geometric fragments is identical to that for arithmetic fragments, except that, of course, instead of the difference between successive elements, the constant ratio between successive elements must be provided: r = s_i+1 / s_i.

Additional Rules

1. The program automatically determines whether each sequence is an integer sequence. To decide whether a given number provided by the user is an integer, you may first read and store it in floating-point and then compare it to its static_cast<int> truncation, as follows.

               double x;  int i;
               bool isInteger = false;
               cin >> x;
               if ( abs(x) < INT_MAX ){
                  i = static_cast<int>(x);
                  isInteger =  (x == i);   // ...same as ( x == double(i) ).
               } 
   

   The constant INT_MAX is the largest integer representable on the given machine and is available from the standard library <climits>.

2. Integer sequences should be processed with integer arithmetic and displayed simply as integers in the usual way, as long as overflow does not occur. Similarly, floating-point sequences should be processed and displayed in floating-point.

3. Your program must automatically detect the case where the elements in an integer sequence fragment become too large to store in the usual int type variable. When this happens, your program should switch to a floating-point representation, both for internal calculation and output.

4. Robust input (correctly handling all possible kinds of errors in user input) is not required. You may assume the user's input is free of format errors and that it is within the limits of the smallest and largest representable values of type double. Any other numerical restrictions on the input should be carefully enforced.

5. Allow users to study rates of decay as well as rates of growth by allowing them to provide the following kinds of parameter values.
   1. negative differences for arithmetic sequence fragments
   2. negative integer exponents for polynomial sequence fragments
   3. positive ratios less than one for geometric sequence fragments

6. Sequences longer than 10 elements should be displayed in lines of 10 elements each, except possibly for the last line.

Sample I/O

  Please specify the type of sequence you wish to examine.
          a  ---  Arithmetic (linear)
          p  ---  Polynomial (specify degree)
          g  ---  Geometric  (exponential)
  Enter 'q' to quit or 'h' to display this menu again.
  apgqh>  a
  Arithmetic sequence { a0 + i*d } for i = 0,1,2, ..., L-1.
  Enter the first element a0:                           3
  Enter the difference d between successive elements:   5
  Enter the fragment length L:                          7    
  Fragment:
  3,  8,  13,  18,  23,  28,  33
  Fragment Sum: 126

  apgqh>  a
  Arithmetic sequence { a0 + i*d } for i = 0,1,2, ..., L-1.
  Enter the first element a0:                         2000000000  
  Enter the difference d between successive elements: 100000000  
  Enter the fragment length L:                        4          
  Fragment:
  2000000000,  2100000000,  2.2e+09,  2.3e+09
  Fragment Sum:   8.6e+09

  apgqh>  a
  Arithmetic sequence { a0 + n*d } for i = 0,1,2, ..., L-1.
  Enter the first element a0:                         8
  Enter the difference d between successive elements: -6
  Enter the fragment length L:                        4
  Fragment:
  8,  2,  -4,  -10 
  Fragment Sum:  -4

  apgqh>  p
  Polynomial sequence { c*(x0+i*d)^n } for i = 0,1,2, ..., L-1.
  Enter the degree n:                       2
  Enter the constant multiplier c:          1
  Enter the initial value of the base x0:   3
  Enter the base increment d:               2
  Enter the fragment length L:              5
  Fragment:
  9,  25,  49,  81,  121
  Fragment Sum:  285

  apgqh>  g
  Geometric sequence { a0 * r^(i-1) }  for i = 1,2, ..., L.
  Enter the first element a0:                           3
  Enter the ratio r between successive elements:        5
  Enter the fragment length L:                          7    
  Fragment:
  3,  15,  75,  375,  1875,  9375,  46875
  Fragment Sum:  58593

  apgqh>  g
  Geometric sequence { a0 * r^(i-1) }  for i = 1,2, ..., L.
  Enter the first element a0:                           3
  Enter the ratio r between successive elements:        0.5
  Enter the fragment length L:                          7    
  Fragment:
  3,  1.5,  0.75,  0.375,  0.1875,  0.09375,  0.046875
  Fragment Sum:  5.95312

  apgqh>  q

Homework 3 Home Page