---

Modular Programming

---

• Modular Programming Example: Rectangle Rule for finding definite integral
  • Review of the Rectangle Rule:

    ---

  • Program formulation (global description):
    • Need a function f(x)
    • Need a start value a
    • Need a stop value b
    • Need the number of segments (intervals) N

    • Algorithm:

      Compute the step size h = (b-a)/N Compute the sum: I = f(a)*h + f(a+h)*h + f(a+2h)*h + ... + f(a + (N-1)h)*h Approximate integral = I

    ---

    ---

  • Program in Pseudo Code:

    a = start of interval b = end of interval N = # segments ====================================== integral = 0.0 h = (b-a)/N x = a for i = 1 to N { integral = integral + f(x)*h x = x + h }

  • Implementation:

    float f(float x) { return(x*x); } int main(int argc, char *argv[]) { extern float f(float); float a, b, h, x, integral; int N, i; cout << "Enter start of interval: "; cin >> a; cout << "Enter end of interval: "; cin >> b; cout << "Enter N (number of segments): "; cin >> N; integral = 0.0; h = (b-a)/N; // Compute step size x = a; for (i = 1; i <= N; i = i + 1) { integral = integral + f(x)*h; // f(x) = f(a), f(a+h), f(a+2h)... x = x + h; // x = a, a+h, a+2h, etc } cout << "Approximate finite integral = " << integral << "\n"; }

    ---

    ---

  • Example Program: (shows function using Rectangle Rule) --- click here          
    • Compile with: CC rect-rule1.C
    • Run: a.out

  ---

• Problems with this implementation
  • Inflexible...
    • The program must use the function with name f

    • If we need to find the integral of 2 different functions the program will be useless.

      Example: the program cannot compute:

      Integral( f(x) from a to b) ------------------------------- Integral( g(x) from a to b)

    • The Rectangle Rule algorithm cannot be easily used by other programs

  • Rapid growth in program complexity...
    • This is a small program, but unless you organise the program into modules, the effort to maintain program correctness will increase rapidly

  ---

  ---

• How to managing program complexity (1): using separate files
  • Computer program parts can be broadly categorized into:

    "Utilities"/"Library functions" : Functions that perform a certain task Applications: programs that coordinate the steps to achieve the desire result

  • "Utilities"/"Library functions" are best stored in different files

    (and combined together in the final program compilation)

    ---

  • Here is an example on how to put functions, subroutines and main program into separate files; and how to compile them into one program:

    // This function is // CHANGED often // -- keep separate float f(float x) { return(x*x); }

    // The algorith // does NOT CHANGED // often // Declare function f before its use !!! extern float f(float); int main(int argc, char *argv[]) { float a, b, h, x, integral; int N, i; ...input a, b, N integral = 0.0; h = (b-a)/N; x = a; for (i = 1; i <= N; i = i + 1) { integral = integral + f(x)*h; x = x + h; } }

    ---

  • Example Program: (Demo above code)                                                

    • The Main program containing the Rectangle Rule: click here
    • The Function subprogram containing the function f(x): click here

  • How to run:
    • CC -c rect-rule2a.C
    • CC -c rect-rule2b.C
    • CC -o rect-rule2 rect-rule2a.o rect-rule2b.o

    • rect-rule2

    ---

  • NOTE:
    • This is NOT New

    • You have seen separate compilation before: click here

  ---

  ---

  ---

  ---

  ---

• Managing program complexity (2): Modular Programming
  • In the Rectangle Rule program, we discern a clear and definite task:

    Determine (an approximation) of a definite integral

  • Unfortunately, the function that implements this task is a main program :

    int main(int argc, char *argv[]) { float a, b, h, x, integral; int N, i; ...input a, b, N // Algorithm is "stuck" in the main program integral = 0.0; h = (b-a)/N; x = a; for (i = 1; i <= N; i = i + 1) { integral = integral + f(x)*h; x = x + h; } }

    As the main program , it cannot be easily deployed in other programs.

    ---

  • The principle of modular programming (to manage program complexity) is:

    Implement well-defined task/operations as one or more functions

    Example:

    int main(int argc, char *argv[]) { float a, b, h, x, integral; int N, i; ...input a, b, N // Well-defined task implemented as a FUNCTION integral = Rectangle_Rule(.....); }

  ---

  ---

  ---

  ---

• Modular Programming Example
  • In order to implement a function to perform a well-defined task we must first determine

    Input information needed to perform the task: input parameters How to convey results to the user: output parameters

    ---

  • Example:
    • Input information needed by the Rectangle Rule algorithm:
      • The function to integrate
      • Start and end of the interval
      • Number of small intervals

    • Output produced by the Rectangle Rule algorithm:
      • A real value representing the approximation of the integral

    ---

  • Implementing the Rectangle Rule algorithm as a function:

    float RectangleRule(float f(float), float a, float b, int N) { float integral, h, x; int i; integral = 0.0; h = (b-a)/N; x = a; for (i = 1; i <= N; i = i + 1) { integral = integral + f(x)*h; x = x + h; } return(integral); }

    This example uses the knowledge about passing function as parameter discussed in this webpage: click here

    ---

  • Using the RectangleRule() function in a main program

    // Declare function f extern float f(float); // Declare function RectangleRule extern float RectangleRule(float f(float), float, float, int); int main(int argc, char *argv[]) { float a, b, integral; int N; cout << "Enter start of interval: "; cin >> a; cout << "Enter end of interval: "; cin >> b; cout << "Enter N (number of segments): "; cin >> N; integral = RectangleRule(f, a, b, N); // Use RectangleRule !!! cout << "Approximate finite integral = " << integral << "\n"; }

    ---

  • Example Program: (Rectangle Rule as a function) ----------
    • The RectangleRule(f,a,b,N) function: click here
    • The Main program (driver program): click here
    • Some function f(x): click here

    • Compile them with:
      • CC -c rect-rule-func.C
      • CC -c rect-rule3.C
      • CC -c rect-rule2b.C
      • CC -o rect-rule3 rect-rule3.o rect-rule-func.o rect-rule2b.o