This document is a C program that allows users to plot selected mathematical functions over a specified range of x values. It includes function definitions for user input, computation of data points, plotting, and finding min/max values, with a specific focus on functions such as sine, exponential, and others. The program is meant to be compiled using the plplot library in a Code::Blocks project setup.

1. Please write it in C, not python
/*------------------------------------------------------------------
File: plotFunctions.c
Author: Gilbert Arbez, Fall 2016
Description: Allows the user to plot a number of functions for
different ranges.
---------------------------------------------------------------------*/
#include <stdio.h>
#include <gng1106plplot.h> // provides definitions for using PLplot library
#include <math.h>
#include <float.h>
// Some definitions
#define NUM_POINTS 500 // Number of points used for plotting
#define X_IX 0 // Row index for storing x values
#define FX_IX 1 // Row index for storing f(x) values
#define TRUE 1
#define FALSE 0
// Structure for user input
typedef struct
{
int fNumber; // function number
double x0; // first value of x to plot
double xf; // final value of x to plot
} F_SELECT;
// function prototypes
void selectFunction(F_SELECT *);
void computeDataPoints(F_SELECT *fsPtr, int n, double [][n]);
double calcFx(double, int);
void plot(int n, double [][n]);
double getMinDouble(double [], int);
double getMaxDouble(double [], int);
/*---------------------------------------------------------------------
Function: main
Description: This function computes a set of points for plotting. The
function calcFx is called to computes the value of f(x) .
Modify calcFx to compute the values of f(x) desired.
In this template, the sin function is used.
------------------------------------------------------------------------*/
void main(void)
{
// Variable declarations
F_SELECT fselect;

2. double points[2][NUM_POINTS]; // row 0 contains values of x
// Get user input
selectFunction(&fselect);
// Compute the data points and save in array
computeDataPoints(&fselect, NUM_POINTS, points);
// Call plot function to plot
plot(NUM_POINTS, points);
}
/*-----------------------------------------------------------------------
Function: selectFunction
Parameters:
sfPtr - Pointer to F_SELECT structure variable to store input data.
Description: Prompts the user to get x0 and xf (range of x for plotting)
and to select a function to plot.
------------------------------------------------------------------------*/
void selectFunction(F_SELECT *sfPtr)
{
// Variable Declarations
int flag;
// Display function menu
printf("1) f(x) = sqrt(|x-1|) + 1n");
printf("2) f(x) = exp(-x)n");
printf("3) f(x) = sqrt(x^2+1) - xn");
printf("4) f(x) = [exp(-x) - 1)]/xn");
printf("5) f(x) = sin(x)+0.1*cos(10.0*x)n");
// Select a function
// Select a range of x for plotting
}
/*-----------------------------------------------------------------------
Function: computeDataPoints
Parameters:
fsPtr - Pointer to F_SELECT structure variable with input data.
n - number of points in the 2D array (i.e. number of columns)
points - 2D array that contains the data points - row X_IX with x values
and row FX_IX with the f(x) values.
Description: Calculates NUM_POINTS points of the function f(x) (selected by the
the user and computed with calcFx), and stored in the
2D array points. points[X_IX] is the 1D array (row X_IX) that
contains the x values while points[FX_IX] is the 1D array (row FX_IX)
that contains the f(x) values.
------------------------------------------------------------------------*/

3. void computeDataPoints(F_SELECT *fsPtr, int n, double points[][n])
{
int ix; // for indexing points, i.e. columns of 2D array
double x; // for incrementing the value of x
double inc; // incrementation value of x
// Setup loop that computes the points and stores in 2D array
// A determinant loop is used to increment x, calculate f(x)
// and store the values in the 2D array.
}
/*-----------------------------------------------------------------------
Function: calcFx
Parameters:
x - the value of x
funtionNum - function number to select function for calculation
Return: The value of f(x)
Description: Calculates the value of f(x). In this case f(x) is selected
using functionNum.
------------------------------------------------------------------------*/
double calcFx(double x)
{
// Variable declations
double fx;
// Instructions
fx = sin(x);
return(fx);
}
/*-------------------------------------------------
Function: plot()
Parameters:
numPoints: number of points in the array, i.e. number of columns
points: reference to 2D array
Return value: none.
Description: Initializes the plot. The following values
in the referenced structure are used to setup
the plot:
points[X_IX][0], points[X_IX][nbrPoints-1] range of horizontal axis
minFx, maxFx - vertical axis range
Note the that the values of minFx and maxFx are determined with
the functions getMinDouble and getMaxDouble. The values in the row
X_IX are assumed to be sorted in increasing order.
Then plots the curve accessed using the contents of each row,
that is, points[X_IX] and points[FX_IX] which are both references

4. to 1D arrays.
-------------------------------------------------*/
void plot(int numPoints, double points[][numPoints])
{
// Variable declaration
double minFx, maxFx; // Minimum and maximum values of f(x)
// Setup plot configuration
plsdev("wingcc"); // Sets device to wingcc - CodeBlocks compiler
// Initialize the plot
plinit();
// Configure the axis and labels
plwidth(3); // select the width of the pen
minFx = getMinDouble(points[FX_IX], numPoints);
maxFx = getMaxDouble(points[FX_IX], numPoints);
plenv(points[X_IX][0],points[X_IX][numPoints-1],
minFx, maxFx, 0, 0);
plcol0(GREEN); // Select color for labels
pllab("x", "f(x)", "Plot of f(x) versus x");
// Plot the function.
plcol0(BLUE); // Color for plotting curve
plline(numPoints, points[X_IX], points[FX_IX]);
plend();
}
/*-------------------------------------------------
Function: getMinDouble
Parameters:
arr: reference to array of double values
n: number of elements in the array
Return value: the smallest value found in the array.
Description: Finds the smallest value in the array.
Uses a determinate loop to traverse the array
to test each value in the array.
-------------------------------------------------*/
double getMinDouble(double arr[], int n)
{
// Variable declarations
double min; // for storing minimum value
int ix; // indexing into an array
// Instructions
min = DBL_MAX; // most positive value for type double
for(ix = 0; ix < n; ix = ix + 1)
{

5. if(min > arr[ix]) min = arr[ix];
}
return(min);
}
/*-------------------------------------------------
Function: getMaxDouble
Parameters:
arr: reference to array of double values
n: number of elements in the array
Return value: the largest value found in the array.
Description: Finds the largest value in the array.
Uses a determinate loop to traverse the array
to test each value in the array.
-------------------------------------------------*/
double getMaxDouble(double arr[], int n)
{
// Variable declarations
double max; // for storing maximum value
int ix; // indexing into an array
// Instructions
max = -DBL_MAX; // most negative value for type double
for(ix = 0; ix < n; ix = ix + 1)
{
if(max < arr[ix]) max = arr[ix];
}
return(max);
}
Plotting is important in engineering and science for displaying results. In this exercise, you shall be
creating software that allows a user to plot one of the five following functions, f(x) for any desired
range of x. f(x)=x1+1f(x)=exf(x)=x2+1xf(x)=xex1f(x)=sin(x)+0.1cos(10x) To include and have
access to the plotting library PLplot, you must create a CodeBlocks project with the PLplot
configuration. When creating the CodeBlocks project, click on "C Console App/PLplot" icon,
ecorntw, and click on the Go button to start the project Wizard. You will note that the template
software included in this project can be compiled and executed. It will plot a sine wave as follows:
A partially completed plotting project is provided in the zipped file PlotFunctions.zip. Download the
file, unzip it, and open the project in CodeBlocks. The program will allow the user to select one of
the five functions presented above and give a range of values for x for plotting. A plot will be
generated according to the user selections. The following are guidelines will help with this
completing the program: 1. The structure type F SELECT is defined to store input from the user,
which consists of the range of values for x,x and x as well as a function number (fumber) which
identifies the number to plot. The following is an example of the interaction with the user to obtain

6. these three values: 2. Complete the function selectFunction to implement the above interaction.
Ensure that the error message is display if the user enters a value outside the valid range ( 1 to 5 )
and prompt the user for a correct value. 3. Complete the function computeDatapoints that will fill in
the 2D array. a. Compute the increment value to increment the value of x (i.e. the value of inc)
using xf,x0 (members of the E_SELECT structure), and n (number of points to compute). Note that
there are only n1 increments to obtain n points. b. When creating the loop to fill in the array, use
the ix to control the loop, not x. Using real values to control a loop is more difficult that using
integer values. c. Use the X IX and FX IX symbolic constants for the row index of the 2D array
points. 4. Modify caleFx to compute the value of f(x) given a function number (provided by the
user). (The version given comes from the project template).a. You will need to change the
parameter list to include a function number. b. Use a decision/branching instruction to use the
proper function for computing the value of f(x). c. Don't forget to update the function prototype. 5.
Modify the plot function to make changes to the plot as follows: a. Draw axes at x=0 and y=0 (hint,
see the plenv function). b. Change the color of the text labels. c. Change the color of the plotted
curve. d. Thicken the line of the plotted curve without changing the thickness of text or axes. e.
Notice the arguments of the plline function call and discuss to understand what is being passed to
the function. 6. Show and explain your code and running program to the TAs for marks. 7. If you
have time, consider trying the following modifications: a. Change the line style, e.g. use a dashed
line (note that the thickness of the line may hide the line style). b. Add text which gives the function
plotted, either in the title or for an additional challenge in the plot itself. he following are some
example plots that your program should produce. Function 3,f(x)=x2+1x:0.5 to +2 unction 4, f(x)=x
ex1:1 to +20 Function 5,f(x)=sin(x)+0.1cos(10x):3.14 to +6.28