1. Your submission must contain each of the following files, as specified:

file	contents
numint.c	functions	mid point numerical integration(double lower limit, double upper limit, int n intervals) → return type: double The parameters lower_limit and upper_limit correspond to the limits of the range $[a,b]$ of $\int_{a}^{b}f(x)dx$. In other words, a = lower_limit and b = upper_limit. The parameter n_intervals corresponds to the number of intervals we divide the range $[a,b]$. You may assume that n_intervals ≥ 1 for this function. The caller function has to pass in an int greater or equal to 1. For this homework, $f(x)$ is called function_to_be_integrated(double x), which is declared in aux.h, and defined in aux.c. However, you are not provided aux.c. Instead, you are given the object code aux.o. You have to include aux.h in your numint.c file and call function_to_be_integrated(…) in mid_point_numerical_integration(…). You are required to implement in numint.c the numerical integration method based on the mid-point rule, with the range [lower_limit, upper_limit] divided into n_intervals intervals. The sum of the approximations for all intervals should be returned.
		trapezoidal numerical integration(double lower limit, double upper limit, int n intervals) → return type: double You are required to implement the numerical integration method based on the trapezoidal rule, with the range [lower_limit, upper_limit] divided into n_intervals intervals.
test_numint.c	functions	main(int argc, char ✶✶ argv) → return type: int The executable of this homework expects 4 arguments. If the executable is not supplied with exactly 4 arguments, return EXIT_FAILURE. The first argument specifies which of the two integration functions you are supposed to run. If the first argument is "-m", you should use the mid-point-rule-based method to perform the numerical integration. If the first argument is "-t", you should use the trapezoidal-rule-based method to perform the numerical integration. If the first argument does not match "-m" or "-t", the executable should exit and return EXIT_FAILURE. The second argument provides the lower limit (double) of the integral You should use atof (from stdlib.h) to convert the second argument into a double. The third argument provides the upper limit (double) of the integral. You should use atof to convert the third argument into a double. The fourth argument provides the number of intervals (int) you should use for the approximation. You should use atoi(…) (from stdlib.h) to convert the fourth argument into an int. If the conversion of the fourth argument results in an int that is less than 1, you should supply 1 (numeric one) as the number of intervals for approximation. The converted values from second, third, and fourth arguements should be supplied to the appropriate integration function. Upon the successful completion of the numerical integration, print the approximation using the format "%.10e\n" using the function printf. (That is the format to be used, and this is the only printf statement in the entire exercise. If you print other messages, your exercises will most likely receive a lower score.) After printing, return EXIT_SUCCESS from the main function.

2. Submissions must meet the code quality standards and the policies on homework and academic integrity.

You should compile your program with the following command:

gcc test_numint.c numint.c aux.o -o hw03

To run your program using the mid-point rule-based integration method, you can use for example,

./hw03 -m 0.0 10.0 5

At it is, this would simply print to the screen 0.0000000000e+00

How do you know whether your implementation is correct when you have no idea what function you are integrating? Well, the integration methods are supposed to work on all functions. What you can do is to test your implementation on some known functions (and functions whose integrands you are familiar with). You can write your own function_to_be_integrated(…) in a different file. Let's call that file my_aux.c. Now, you compile with the following command:

gcc test_numint.c numint.c my_aux.c -o hw03

Your implementation of function_to_be_integrated(…) should include simple functions such as:

$f(x) = 1$, $f(x) = x$

In these cases, the numerical integration should be exact because we are integrating a constant function or a linear function.

You can try to use piece-wise linear function, such as:

$$ f(x) = \left\{ \begin{array}{ll} 0 & \quad x < 1 \\ x - 1& \quad x ≥ 1 \end{array} \right. $$ You can try quadratic functions or functions with higher order. You can also try functions available in math.h. However, in that case, you will have to compile with the -lm option:

gcc test_numint.c numint.c my_aux.c -o hw03 -lm

Note that this is in fact how we are going to evaluate your implementation, by using different implementations of function_to_be_integrated(…).

For each known function that you have implemented in my_aux.c, you should try to perform integration with only 1 interval, and then 2 intervals, and perhaps some other numbers of intervals. You should choose a number of intervals that is easy for you to verify the correctness of your implementation. You may want to choose the number of intervals together with an appropriate pair of lower and upper limits. For example, if you choose 3 as the number of intervals, it would be easier for you to work out the expected solution by hand if difference of upper limit and lower limit is divisible by 3.

Also, pick the lower and upper limits so that you can verify the results by hand easily. For example, if the number of intervals is 10, and if the method for integration is based on the mid-point rule, it may be better to use a lower limit of 0.5 and an upper limit of 10.5 because the mid-points for the 10 intervals would be integers, which might be easier for you to evaluate. On the other hand, if the method is based on the trapezoidal rule, it may be better to use a lower limit of 0 and an upper limit of 10 because the left and right end points of the intervals would be integers.

You can also use your implementation to check against your implementation. Let's assume that you have verified that your implementation is correct when you use only 1 interval for integration. Let's pick a lower limit of 0 and an upper limit of 10, and you use 10 intervals. You can run the case for integration with 1 interval 10 times, each time with different ranges: 0 and 1, 1 and 2, 2 and 3, ..., 9 and 10. The results you get from all 10 ranges should be summed and compared to the result when you run it on the case of 10 intervals with 0 and 10 being the limits.

Be aware that you are dealing with floating point representation (in double) in this exercise. The order of arithmetic operations performed in your implementation is likely different from your classmates' implementations and my implementation. You should not expect your printed output to match others even with the same pair of limits and the same number of intervals. Similarly, if you use your implementation to test against your implementation, you should not expect the sum of the 10 results to match the result from a single run exactly. The reason is that when a double is printed through the format "%.10e\n", there is some loss in accuracy in the printed double on the screen because the format prints only the first 10 significant numbers after the decimal point.

valgrind --log-file=memcheck.log ./hw03 -m 0.0 10.0 5 

valgrind ./hw03 -m 0.0 10.0 5