Contents

Let’s C:A Supplement to

Computer Programming Lab

Good programmers use their brains, but good guidelines save us having to think out every case.
Francis Glassborow

This lab supplement provides a list of programs that can be written and executed by students as pro-
gramming lab exercises. Hints and variations have been provided to make the exercises interesting and
easier to implement. A special effort has been made to include all the lab exercises prescribed in the
syllabus for the C Programming and Data Structures course at JNTU.

I. Just Beginning
C code. C code run. Run code run...please!
Barbara Ling
1. Write a C program to find the sum of individual digits of a positive integer.
Hint: For extractning the digits, make use of the % operator. If you get stuck, refer to Chapter 6.
Variation: The running sum of digits is the final single digit sum, e.g., the running sum of
digits of the number 3249 is 9 (3 + 2 + 4 + 9 = 18 Æ 1 + 8 = 9) Write a program to calculate the
running sum of the digits of a positive integer.
2. The Fibonacci sequence is defined as follows: the first and second terms in the sequence are 0 and
1. Subsequent terms are found by adding the preceding two terms in the sequence. Write a C
program to generate the first n terms of the sequence.
Hint: The simplest way to generate the Fibonacci series is to use a for loop. However, the Fibonacci
sequence may also be generated using a recursive function. The following is a recursive function
which generates the nth Fibonacci number
int fibonacci(int n)
{
if (n < 3) //stop condition
return (1); //stop condition met
}
else
return ( fibonacci(n-2) + fibonacci(n-1));
// recursive calling
}
 Let’s C:A Supplement to Computer Programming Lab 55
Write a function which generates and prints the first n terms of the Fibonacci sequence recursively.
Variation: The number (1 + 5 )/2 is called the golden ratio or the number phi and is denoted by
j. The ratio of two consecutive Fibonacci numbers (F n /Fn – 1) tends closer and closer to phi as we
go higher up in the Fibonacci series. Given the approximated value of phi as 1.61803398875,
write a program which calculates the ratio of two consecutive Fibonacci numbers (F and F n – 1),
compares it to the given value of phi, and calculates the error in the value computed.
3. Write a C program to generate all the prime numbers between 1 and n, where n is a value
supplied by the user.
Hint: n is prime if it is indivisible by numbers from 2 to n/ 2.
4. Write a C program to calculate the following sum:
Sum = 1 – x2/2! + x4/4! – x6/6! + x8/8! – x10/10!
Hint: n!=1*2*3*...*n. For calculating powers of x, use the pow() function defined in math.h
(see Chapter 7) or write a user-defined function to calculate the nth power of a given number.
5. Write a C program to find the roots of a quadratic equation.
Hint: For a quadratic equation of the form
ax2 + bx + c = 0
the roots are given by
x1 = (– b + sqrt(b2 – 4ac))/2a
x 2 = (– b – sqrt(b2 – 4ac))/2a
when the discriminant (b2 – 4ac) is positive (see Chapter 9).
Variation: Write a program which will display complex roots as well as real roots. This program
will calculate the roots of the quadratic equation even if the discriminant (b2 – 4ac) is negative.

II. ‘To Iterate is Human, to Recurse, Divine’

In order to understand recursion, one must first understand recursion.

Anonymous

1. Write C programs that use recursive and non-recursive functions to find the factorial of a given
integer.
Hint: n! = 1*2*3....*n
2. Write C programs that use recursive and non-recursive functions to find the GCD (greatest com-
mon divisor) of two given integers.
Hint: The non-recursive function for calculating the GCD of two numbers is given below

int gcd(int a,int b)

{ int r;
do{
r = a % b;
a = b;
b = r;
}while(b!=0);
}

3. Write C programs that use recursive and non-recursive functions to solve the Towers of Hanoi
problem.
56 C Programming & Data Structures

Hint: Towers of Hanoi are discussed in detail in Chapter 7. A simple algorithm for a recursive
solution to the Towers of Hanoi is as follows:

Algorithm towers (numDisks, source, dest, auxiliary)

Recursively move disks from source to destination.
Pre numDisks is number of disks to be moved
source, destination, and auxiliary towers given
Post steps for move printed
1 Print(“Towers: ”, numDisks, source, dest, auxiliary)
2 if (numDisks is 1)
1 print (“Move from ”, source, “ to ”, dest)
3 else
1 towers (numDisks – 1, source, auxiliary, dest, step)
2 print (“Move from ” source “ to ” dest)
3 towers (numDisks – 1, auxiliary, dest, source, step)
4 end if
end towers

The non-recursive solution may be implemented using three stacks which represent the three
needles.
Variation: Try writing a code which will visually display the steps of the solution to the Towers
of Hanoi. Use the * symbol and spaces to create your figure, for example, the initial state of the
towers with three disks may be represented as:

* * *
* * *
*** * *
***** * *
******* * *
A B C

III. Back to Basics

Do not worry about your difficulties in mathematics. I can assure you that mine are still greater.
Albert Einstein

1. The total distance traveled by vehicle in t seconds is given by distance = ut + 1/2at2 where u and
a are the initial velocity (m/sec.) and acceleration (m/sec2). Write C program to find the distance
traveled at regular intervals of time given the values of u and a. The program should provide
the flexibility to the user to select his own time intervals and repeat the calculations for different
values of ‘u’ and ‘a’.
2. Write a C program, which takes two integer operands and one operator from the user, performs
the operation and then prints the result. (Consider the operators +,-,*, /, % and use switch
statement)
Hint: Refer to Chapter 5 for details.
3. Write a C program to find both the largest number and smallest number in a list of integers.
Hint: Store the list in an array. Take two variables, max and min. Assign the first number in the
list to both max and min. Then scan the list and compare max and min to each member of the list.
Update the values of max and min.
 Let’s C:A Supplement to Computer Programming Lab 57
Alternatively, separate functions for finding maximum and minimum can be written. These func-
tions will take the array of integers as an argument and return the maximum and minimum
respectively.
4. Write a C program that uses functions to perform the following matrix operations:
(i) Addition of two matrices
(ii) Multiplication of two matrices
Hint: The order of a matrix is given by m × n where m is the number of rows of the matrix and
n is the number of columns of the matrix. For addition, the order must be the same. For multipli-
cation, the number of columns of the first matrix must be equal to the number of rows of the
second matrix. The simplest algorithm for matrix multiplication is

for(i=0;i<m;i++)
for(j=0;j<n;j++)
for(k=0;k<p;k++)
C[i][k]+ = A[i][j] * B[j][k];

where Am × n and Bn × p are the two matrices being multiplied and Cm × p is the product matrix.
Variation: Modify your matrix program to perform all matrix functions such as calculating the
determinant of a given matrix, generating the inverse and transpose of a matrix, and identifying
whether a given matrix is a null matrix or not.

IV. String Theory?

Besides a mathematical inclination, an exceptionally good mastery of one’s native tongue

is the most vital asset of a competent programmer.
Edsger Dijkstra

1. Write a C program that uses functions to perform the following operations:

(i) To insert a sub-string into given main string from a given position.
(ii) To delete n characters from a given position in a given string.
Hint: Take the user’s choice as to whether a sub-string has to be deleted or inserted and use a
switch statement to perform the requisite operations. The insertion and deletion functions are
shown below:

void insertstring(char ms[],char ss[],int posn)

{
char s1[MAX_LEN],s2[MAX_LEN];
int i;
/*The idea is to place the characters in the string before and
after
* the given positon in two separate strings and then insert
* the substring*/
for(i=0;i<posn;i++)
s1[i]=ms[i];
s1[posn]=’\0';//the strings must be null-termi nated
for(i=posn;i<strlen(ms);i++)
s2[i-posn]=ms[i];
s2[strlen(ms)-posn]=’\0';
58 C Programming & Data Structures

//The following steps perform the insertion strcat(s1,ss);

strcat(s1,s2);
//The new string is copied back
strcpy(ms,s1);
return;
}
void del_n_chars(char s[],int n,int p)

{
int i;
if(n==0) return;
for(i=p;i<strlen(s);i++)
s[i]=s[i+n];
return;
}

2. Write a C program to determine if a given string is a palindrome or not.

Hint: A palindrome is a string which appears the same, irrespective of whether it is read forward
or backward. For example, racecar is a palindrome. To check whether a string is a palindrome,
compare the first character with the last, the second with the second last, and so on until a mis-
match is obtained. If no mismatch is obtained, the string is a palindrome. Alternatively, reverse
the string and store it in another. Then compare the two strings using the strcmp() function.
Variation: It may happen that the string is a palindrome, but the program doesn’t detect it
because of whitespaces or mismatch between uppercase and lowercase characters, e.g., AbBa.
Enhance your program to take care of these conditions.
3. Write a C program that displays the position or index in a string S where the string T begins, or
–1 if S doesn’t contain T.
Hint: Scan for the starting character of T in S, then check if the entire string is present following
that character. Alternatively, the strstr() function can be used. This function returns a pointer
to the starting position of a substring in a string. This pointer may be used to get the starting index.
The following program is an implementation using the strstr() function:

/*This program searches for a string within another

* using the standard string handling function strstr().
* The student is advised to attempt the program without using
* this function.*/
#include<stdio.h>
#include<string.h>
#define MAX_LEN 100
int main()
{
char str1[MAX_LEN],str2[MAX_LEN],*pos;
int posn;
printf(“Enter the main string: “);
scanf(“%[^\n]”,str1);
printf(“Enter the string to search for: “);
scanf(“ %[^\n]”,str2);//notice space in scanf
 Let’s C:A Supplement to Computer Programming Lab 59
pos=strstr(str1,str2);
if(pos) posn=pos-str1+1;//calculating position of substring
else posn=-1;
printf(“%s found in %s at position %d\n”,str2,str1, posn);
return 0;
}

4. Write a C program to count the lines, words, and characters in a given text.
Hint: Characters can be alphabets, numbers, or special characters (excluding whitespaces). Lines
are terminated by CRLF(\n). Words are terminated by whitespaces. Chapter 13 discusses the
above counting implementations for files. Write the program for strings and then for files.

V. Number Crunching

First, solve the problem. Then, write the code.

John Johnson

1. Write a C program to generate Pascal’s triangle.

Hint: The Pascal’s triangle is a triangle wherein the nth row gives the integer coefficients of all the
terms in the expansion of (x + y)n .

(x + y)n = nC0x n + nC1xn – 1y + nC2xn – 2y2 + ◊◊◊◊ + nCnyn

n
Cr = n! / (r!(n – r)!)
n
Cr = n – 1Cr + n–1Cr – 1 (recursive formula for calculating the coefficients)

The Pascal’s triangle with five rows is:

1 (x + y)0
1 1 (x + y)1
1 2 1 (x + y)2
1 3 3 1 (x + y)3
1 4 6 4 1 (x + y)4

2. Write a C program to construct a pyramid of numbers.

Hint: There are many different ways to depict a pyramid of numbers. A few of these are illus-
trated below:

1 5 1 5
2 2 4 5 2 1 2 4 5 4
3 3 3 3 4 5 3 2 1 2 3 3 4 5 4 3
4 4 4 4 2 3 4 5 4 3 2 1 2 3 4 2 3 4 5 4 3 2

The pyramids illustrated above have five rows each. However, a good pyramid of numbers pro-
gram must input the number of rows from the user and generate the pyramid accordingly. The
simplest code will use two for loops—one to print the numbers and one to print the spaces.
3. Write a C program to read in two numbers, x and n, and then compute the sum of this geometric
progression:
1 + x + x2 + x3 + … + xn
60 C Programming & Data Structures

For example, if n is 3 and x is 5, then the program computes 1 + 5 + 25 + 125. Print x, n, and the
sum. Perform error checking. For example, the formula does not make sense for negative expo-
nents, if n is less than 0. Have your program print an error message if n < 0, then go back and read
in the next pair of numbers of without computing the sum. Are any values of x also illegal? If so,
test for them too.
Hint: The sum of geometric series is given by
(xn + 1 – 1)/(x – 1) for x > = 1
(– xn + 1)/(1 – x) for 0 < x < 1
4. 2’s complement of a number is obtained by scanning it from right to left and complementing all
the bits after the first appearance of a 1. Thus 2’s complement of 11100 is 00100. Write a C
program to find the 2’s complement of a binary number.
Hint: See Appendix B for details on 1’s complement and 2’s complement.
Variation: An alternative method to obtain the 2’s complement is by first obtaining the 1’s
complement. The 1’s complement is arrived at by complementing all the digits of the binary
number (1’s complement of 11100 is 00011). The 2’s complement is obtained by adding 1 to the
1’s complement. Therefore, the 2’s complement of 11100 is given by 00011 + 1. Write a program
which calculates the 2’s complement of a given number through this method. Your program must
display the 1’s complement and the 2’s complement.
5. Write a C program to convert a Roman numeral to its decimal equivalent.
Hint: The various Roman numeral symbols and their decimal equivalents are as follows:
I = 1; V = 5; X = 10; L = 50; C = 100; D = 500; M = 1000
These numerals are written with a single over bar to indicate multiplication by 1000 and with a
double over-bar to indicate multiplication by a million. Therefore, V = 5000 and V = 5000000.
6. Write a C program that uses functions to perform the following operations:
(i) Reading a complex number
(ii) Writing a complex number
(iii) Addition of two complex numbers
(iv) Multiplication of two complex numbers
(Note: represent complex numbers using structures.)
Hint: A complex number is of the form a + ib, where a is the real part and b is the imaginary part.
(a + ib) + (c + id) = (a + b) + i(c + d)
(a + ib) * (c + id) = (ac – bd) + i(ad + bc)
A complex number may be represented as

typedef struct{
int re; //real part
int im; //imaginary part
}complex;

The following function prototypes may be used:

void read_complex(&complex);
void print_complex(complex);
complex add_complex(complex,complex);
complex multiply_complex(complex,complex);

Variation: Write a function to implement division of two complex numbers

 Let’s C:A Supplement to Computer Programming Lab 61
VI. Files, Lists, Stacks, Queues—Office Work?

Make everything as simple as possible, but not simpler.

Albert Einstein

1. Write a C program which copies one file to another.

Hint: Refer to Chapter 13
2. Write a C program to reverse the first n characters in a file.
(Note: The file name and n are specified on the command line.)
Hint: Read the first n characters of the file, put them in a string, and reverse it. Then write the
string back to the file. The fseek() function can be used to access any byte within a file.
However, it has limited applicability to text files.

int fseek(FILE* stream,long offset,int wherefrom);

We can use the fseek() function to position the file pointer to the beginning of the text file, after
we have read n characters from it. Alternatively, the first character can be interchanged with the
nth, the second with the (n – 1)th, and so on, using the fseek() function directly. For details about
the functioning of fseek(), see Section 14.2.
3. Write a C program that uses functions to perform the following operations on singly linked list:
(i) Creation (ii) Insertion (iii) Deletion (iv) Traversal
Hint: See Chapter 16 for details on singly linked lists. Use a dummy node as described in Section
16.3 for an easier implementation.
Variation: Write a program to perform similar operations on a circularly linked list.
4. Write a C program that uses functions to perform the following operations on doubly linked list:
(i) Creation (ii) Insertion (iii) Deletion (iv) Traversal in both ways
Hint: See Section 16.3 for details on doubly linked lists.
Variation: Write a program to implement the above functions in a doubly circularly linked list.
5. Write C programs that implement stack operations using
(i) Arrays (ii) Pointers
Hint: A stack is a LIFO list. All insertion (push) and deletion (pop) is performed at one end of the
stack, called the top. The different implementations of stacks and the relevant operation functions
are detailed below:
(i) As an array
typedef struct{
int stack_elements[MAX_LEN]; //MAX_LEN is a predefined
macro
int tos; // top of stack
}stack,*stackptr;

Sample function definitions

stackptr createstack()
{/* The stack is dynamically created. All elements of the
stack are initialised to -9999 and tos is initialised to -1*/
stackptr sptr;
int i;
62 C Programming & Data Structures

sptr = (stackptr)malloc(sizeof(stack));
for(i=0;i<MAX_LEN;i++)
sptr->stack_elements[i] = -9999;
sptr->tos = -1;
return sptr;
}
int push(stackptr sptr,int n)
{//push an integer on to the stack
if(isfull(sptr)) {printf(“Stack is full\n”);return 0;}
(sptr->tos)++;
sptr->stack_elements[sptr->tos] = n;
return 1;
}
int pop(stackptr sptr, int* p)
{ //pops the top element from the stack and returns it in p
if(isempty(sptr)) {printf(“Stack is empty\n”);return 0;}
else *p = sptr->stack_elements[sptr->tos];
(sptr->tos)—;
return 1;
}
int isempty(stackptr sptr)
{ //returns true if stack is empty and false otherwise
if(sptr->tos==-1) return 1;
else return 0;
}
int isfull(stackptr sptr)
{ //returns true if stack is full and false otherwise
if(sptr->tos==MAX_LEN-1) return 1;
else return 0;
}

(ii) As a linked list

The stack node may be implemented as:

typedef struct stacknodetyp{

int val;
struct stacknodetyp* next;
}stacknode, *stacknodeptr;

The stack may be implemented as:

typedef struct{
int count; //keeps track of how many elements there are in the
stack
stacknodeptr top_of_stack; //points to the 1st el- ement in
the stack
}stack,*stackptr;
 Let’s C:A Supplement to Computer Programming Lab 63
Sample function prototypes:

stackptr createstack(); //initialise count to 0 and the top pointer

to null
int isempty(stackptr);
int push(stackptr,int);
int pop(stackptr,int*);

Note that the isfull() function is not required here. However, it can be implemented if the
programmer decides that the stack can only have a certain maximum number of elements. In
which case, isfull() will compare the value of count to that of the maximum number of stack
elements allowed.
6. Write C programs to implement queue operations using
(i) Arrays (ii) Pointers
Hint: A queue is a FIFO list. All insertion (enqueue) is performed at the rear and all deletion
(dequeue) is performed at the front. The different implementations of queues and the relevant
operation functions are detailed below:
(i) As an array
typedef struct{
int queue_elements[MAX_LEN]; //MAX_LEN is a predefined
macro
int front; // front of queue
int rear; //rear of queue
}queue,*queueptr;

Sample function definitions

queueptr createqueue()
{/* The queue is dynamically created. All elements of the queue are
initialised to -9999 and front and rear are initialised to -1*/
queueptr qptr;
int i;
qptr = (queueptr)malloc(sizeof(queue));
for(i=0;i<MAX_LEN;i++)
qptr->queue_elements[i] = -9999;
qptr->front = qptr->rear = –1;
return qptr;
}

int enqueue(queueptr qptr,int n)

{ //enqueue an element at the rear
if(isfull(qptr)) {printf(“Queue is full\n”);return 0;}
(qptr->rear)++;
qptr->queue_elements[qptr->rear] = n;
return 1;
}
64 C Programming & Data Structures

int dequeue(stackptr sptr, int* p)

{ //removes an element from front of queue and returns
it in p
if(isempty(qptr)) {printf(“Queue is empty\n”);return 0;}
else *p = qptr->queue_elements[qptr->front];
(qptr->front)++;
return 1;
}

int isempty(queueptr qptr)

{ //returns true if queue is empty and false otherwise
if((qptr->front == -1 && qptr->rear == -1)|| (qptr- >front >
qptr–>rear)) return 1;
else return 0;
}

int isfull(queueptr qptr)

{ //returns true if queue is full and false otherwise
if(qptr->rear==MAX_LEN-1) return 1;
else return 0;
}

Note that this implementation of isfull() is not entirely correct. The reason is that some elements
may have been dequeued at the front, while the rear pointer still remains at the last position in the
array. The queue might actually even be empty! Hence, even though the queue is not full, the
function will return true. Think about a way around this.
(ii) As a linked list
The queue node may be implemented as:

typedef struct queuenodetyp{

int val;
struct queuenodetyp* next;
}queuenode, *queuenodeptr;
The queue may be implemented as:
typedef struct{
int count; //keeps track of how many elements there are
in the queue
queuenodeptr front, rear; //pointers to front and rear of
the queue
}queue,*queueptr;
Sample function prototypes:
queueptr createqueue(); //create queue
dynamically.initialise count to 0 and front and rear
pointers to null
int isempty(queueptr);
int enqueue(queueptr,int);
int dequeue(queueptr,int*);
 Let’s C:A Supplement to Computer Programming Lab 65
7. Write a C program that uses stack operations to perform the following:
(i) Converting an infix expression into postfix expression
(ii) Evaluating the postfix expression
Hint: These stack applications have been discussed in Chapter 16.
8. Write a C program that uses functions to perform the following:
(i) Creating a Binary Tree of integers
(ii) Traversing the above binary tree in preorder, inorder, and postorder.
Hint: A binary search tree can be implemented as:

typedef struct bststruct{

int val;
struct bststruct *lchild, *rchild;
}bsttyp,*bstptrtyp;

Prototypes for standard functions:

void insertinBST(bstptrtyp* rptr,int key);
bstptrtyp insertinBST(bstptrtyp root,int key); //Alter-native in-
sert
void deletefromBST(bstptrtyp* rptr,int key);
bstptrtyp deletefromBST(bstptrtyp root,int key); //Al-ternative
delete
bstptrtyp predinBST(bstptrtyp rp,int key); //finds pred-ecessor
bstptrtyp succinBST(bstptrtyp rp,int key); //finds suc-cessor

Traversal
Preorder traversal: Node Æ Left Child Æ Right Child
Inorder traversal: Left Child Æ Node Æ Right Child
Postorder traversal: Left Child Æ Right Child Æ Node
Sample implementation of inorder traversal

void inOrderTraversal(bstptrtyp root)

{
if(rp==NULL) return;
else
{
inOrderTraversal(rp->lchild);
printf(“%d “,rp->val);
inOrderTraversal(rp->rchild);
}
}

The preorder and postorder implementations are similar to the function given above.

VII. Searching and Sorting

It’s not at all important to get it right the first time.

It’s vitally important to get it right the last time.
Andrew Hunt and David Thomas
66 C Programming & Data Structures

1. Write C programs that use both recursive and non-recursive functions to perform the following
searching operations for a key value in a given list of integers : (i) Linear search (ii) Binary
search
Hint: Non-recursive methods for linear and binary search are discussed in Chapter 15. A recur-
sive function for binary search on a sorted array is given below:

int binary_recur(int array[],int index_begin,int

index_final,int key)
{
int mid;
if (index_begin <= index_final)

{
mid=( index_begin + index_final)/2;
if (array[mid]==key)
return mid;
else if (key<array[mid])
return binary_recur(array, index_begin, mid-1,key);
else
return binary_recur(array, mid-1, index_final, key);
}
return -1;
}

2. Write C programs that implement the following sorting methods to sort a given list of integers in
ascending order:
(i) Bubble sort (ii) Quick sort
Hint: For bubble sort see Section 15.1 and for quick sort see Section 15.2.
3. Write C programs that implement the following sorting methods to sort a given list of integers in
ascending order:
(i) Insertion sort (ii) Merge sort
Hint: For insertion sort see Section 15.1 and for merge sort see Section 15.2.

VIII. Numerical Methods

Measuring programming progress by lines of code is like

measuring aircraft building progress by weight.
Bill Gates

1. Write C programs to implement the Lagrange interpolation and Newton–Gregory forward

interpolation.
Hint: Given a set of n data points, the kth Lagrange interpolating polynomial is defined as:

( x − x1 ) ... ( x − x k −1 ) ( x − x k )... ( x − x n )
Qk (x) = for 1 £ k £ n
( x − x1 ) ... ( x k − x k −1 ) ( xk − x k ) ... ( x k − xn )

The Newton–Gregory forward interpolation is also called Newton’s forward difference formula
and is given as
 Let’s C:A Supplement to Computer Programming Lab 67

α (α − 1)... (α − ( n − 2))
f(x1 + a h) ª f(x1) + a Df(x1) + … + Dn–1 f (x1)
( n − 1)!
2. Write C programs to implement the linear regression and polynomial regression algorithms.
Hint:
Linear Regression
We have a set of n data points. We need to determine the best-fit line for these points. The least
squares method is employed here to obtain the line. The least squares method is as follows—for a
set of n data points, the best fit line is determined by the following formulae:
Let the best fit line be
y = mx + c
m and c are given by

n
∑ ( xi − x ) ( yi − y )
i =1
m = n 2
∑ ( xi − x )
i =1

c = y − mx
A sample program using 20 data points follows:
U /*Best–fit line using least-squares method*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define MAX_POINTS 20

int main()
{
int K; / * loop counter * /
int N; / * INPUT: Number of points * /
d o u b l e M, C; / * Slope and Y-intersection * /
double X[MAX_POINTS]; / * x-coordinates of points * /
double Y[MAX_POINTS]; / * y-coordinates of points * /
double Xmean; / * Average value for x coord. * /
double Ymean; / * Average value for y coord. * /
double SumX; / * Sum of X coordinate values * /
double SumXY; / * Sum of product X*Y * /
printf(“Enter number N of data points:”);
scanf(“%d”,&N);
if(N > 20)
{

UAll programs bearing the U symbol in this supplement have been adapted from the C program supplement to John H.
Mathews 1992, Numerical Methods for Mathematics, Science, and Engineering, Prentice Hall, Englewood Cliffs,
New Jersey.
68 C Programming & Data Structures

printf(“ Not prepared for more than 20 points. Terminating. Sorry\n”);

exit(0);
}
printf(“INPUT of data points :\n”);
printf(“Example : x = –2 and y = 1, so type : –2 1\n”);
printf(“ \n”);
for(K = 1; K <= N; K++)
{
printf(“Enter co-ordinates of data point number %d: “,K);
scanf(“%lf %lf”, &X[K-1],&Y[K-1]);
}
Xmean = 0.0;

/* calculate X-mean value */

for(K = 1; K <= N; K++)
Xmean+ = X[K-1];
Xmean = Xmean / N;

Ymean = 0.0;

/* calculate Y-mean value */

for(K = 1; K <= N; K++)

Ymean+ = Y[K-1];

Ymean = Ymean / N;

SumX = 0.0;

/* Sum of (x_k - Xmean) squared */

for(K = 1; K <= N; K++)

SumX+ = pow( (X[K-1] - Xmean),2 );

SumXY = 0.0;

// Sum of (x_k - Xmean) * (Y_k - Ymean)

for(K = 1; K <= N; K++)

SumXY+ = ( (X[K-1] - Xmean) * (Y[K-1] - Ymean) );

M = SumXY/SumX; /* Compute the slope * /

C = Ymean - M * Xmean; /* Compute the y-intersection */

printf( “ \n” );
printf(“ Least-square line y = Mx + C\n”);
 Let’s C:A Supplement to Computer Programming Lab 69
printf(“ The coefficients are :\n”);
printf(“ M = %lf and C = %lf .\n”, M, C);
printf( “ \n” );
return 0;
} /* End of main program */

Polynomial Regression
Any polynomial can be chosen to fit a set of data points. Data linearization is used to construct the
non-linear fit. The following program gives a choice of 10 polynomials to the user. The user can
use any of these polynomials to fit their set of data points. Depending on the user’s choice, the
program calculates the coefficients of the corresponding polynomial from the data set points.

U/*Best-fit nonlinear curve determination using data linearization”

Available curves are :
A D 1 x
Y= + B, Y= , Y= , Y=
x x +C Ax + B A + Bx
y = A ln(x) + B, y = C exp(Ax), y = C * x , y = (Ax +B)
L
y = c * x * exp (-D x), Y= .
1 + c * exp (Ax)
*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define MAX_POINTS 20

int main()
{
int K; /* loop counter * /
int N; /* INPUT: Number of points * /
double A, B; /* Slope and Y-intersection * /
double X[MAX_POINTS]; /* x-coordinates of points * /
double Y[MAX_POINTS]; /* y-coordinates of points * /
double Xmean; /* Average value for x coord. * /
double Ymean; /* Average value for y coord. * /
double SumX; /* Sum of X coordinate values * /
double SumXY; /* Sum of product X*Y * /
int ch; /* Case of nonlinear Regression
(user’s choice) */
double C, D, L; / * Coefficients in formulae * /

printf(“Enter number N of data points:”);

scanf(“%d”,&N);
if(N > 20)
{
printf(“ Not prepared for more than 20 points. Terminat- ing. Sorry\n”);
70 C Programming & Data Structures

exit(0);
}
printf(“The number of data points N = %d\n”, N);

printf(“INPUT of data points :\n”);

printf(“Example : x = -2 and y = 1, so type : -2, 1\n”);
printf(“ \n”);
for(K = 1; K <= N; K++)
{
printf(“Enter coordinates of data point number %d: “,K);
scanf(“%lf, %lf”, &X[K-1],&Y[K-1]);
}

/* Select case */

printf(“=======Select one of the following polynomials to fit

your data set=======\n”);
printf(“(1) y = A/x + B (2) y = D/[x+C]\n”);
printf(“(3) y = 1/[Ax + B] (4) y = x/[A + Bx]\n”);
printf(“(5) y = A ln(x) + B (6) y = C * exp(Ax)\n”);
printf(“(7) y = C * x^A (8) y = [Ax + B]^-2\n”);
printf(“(9) y = C * x exp(-Dx)\n”);
printf(“(10) y = L / [ 1 + C * exp(A*x) ]\n”);
printf(“===============================================\n”);
do
{
printf(“Enter your choice (1-10): “);
scanf(“%d”, &ch);
}while( (ch < 1) || (ch > 10) );
/* make transformation(s) to linearise the data j = 1, 2,...,
N */
switch(ch) {
case 1: for (K = 1; K <= N; K++)
X[K-1] = 1.0 / X[K-1];
break;

case 2: for (K = 1; K <= N; K++)

X[K-1] = X[K-1] * Y[K-1];
break;

case 3: for (K = 1; K <= N; K++)

Y[K-1] = 1.0 / Y[K-1];
break;

case 4:
for(K = 1; K <= N; K++)
 Let’s C:A Supplement to Computer Programming Lab 71
X[K-1] = 1.0 / X[K-1];
for(K = 1; K <= N; K++)
Y[K-1] = 1.0 / Y[K-1];
break;

case 5:
for(K = 1; K <= N; K++)

X[K-1] = log(X[K-1]);
break;

case 6:
for(K = 1; K <= N; K++)
Y[K-1] = log(Y[K-1]);
break;

case 7:
for(K = 1; K <= N; K++)
X[K-1] = log( X[K-1] );
for(K = 1; K <= N; K++)
Y[K-1] = log( Y[K-1] );
break;

case 8:
for(K = 1; K <= N; K++)
Y[K-1] = sqrt(Y[K-1]);
break;
case 9:
for(K = 1; K <= N; K++)
Y[K-1] = log( Y[K-1] / X[K-1] );
break;

case 10:
printf(“ Enter the value of the constant L: “);
scanf(“%lf”, &L);
for(K = 1; K <= N; K++)
Y[K-1] = log(L / Y[K-1] - 1.0);
break;

}//end switch

Xmean = 0.0;

/* calculate X-mean value */

for(K = 1; K <= N; K++)

Xmean+ = X[K-1];
Xmean = Xmean / N;

Ymean = 0.0;

/* calculate Y-mean value */

72 C Programming & Data Structures

for(K = 1; K <= N; K++)

Ymean+ = Y[K-1]; Ymean = Ymean / N;

SumX = 0.0;
/* Sum (x_k - Xmean) squared */

for(K = 1; K <= N; K++)

SumX+ = pow( (X[K-1] - Xmean),2 );

SumXY = 0.0;

/* Sum (x_k - Xmean) * (Y_k - Ymean) */

for(K = 1; K <= N; K++)

SumXY+ = ( (X[K-1] - Xmean) * (Y[K-1] - Ymean) );

A = SumXY/SumX; /* Compute the slope * /

B = Ymean - A * Xmean; /* Compute the y-intersection */

/* Make coefficient transformation(s) if necessary */

switch(ch)
{
case 2:
C = -1.0 / A;
D = -B / A;
break;

case 6:
C = exp(B);
break;

case 7:
C = exp(B);
break;

case 9:
C = exp(B);
D = -A;
break;

case 10:
C = exp(B);
break;

}//end switch

/* Output */

printf(“The least-squares curve for the data is:\n”); printf( “

\n” );
switch(ch) {
case 1:
 Let’s C:A Supplement to Computer Programming Lab 73
printf(“y = %lf / x + %lf\n”, A, B);
break;

case 2:
printf(“y = %lf / [ x + %lf]\n”, D, C);
break;

case 3:
printf(“y = 1 / [ %lf * x + %lf ]\n”, A, B);
break;

case 4:
printf(“y = x / [ %lf + %lf * x ]\n”, A, B);
break;

case 5:
printf(“y = %lf * ln(x) + %lf\n”, A, B);
break;

case 6:
printf(“y = %lf * exp(%lf * x)\n”, C, A);
break;

case 7:
printf(“%lf * x^(%lf)\n”, C, A);
break;

case 8:
printf(“y = [ %lf * x + %lf ]^(2)\n”, A, B);
break;

case 9:
printf(“y = %lf * x * exp(- %lf * x)\n”, C, D);
break;

case 10:
printf(“y = %lf / [ 1 + %lf * exp(%lf * x)\n”, L, C, A);
break;
}//end switch
} /* End of main program */

3. Write C programs to implement Trapezoidal and Simpson methods.

Hint:
Trapezoidal Integration
Trapezoidal integration is one of the best-known approximation techniques for definite integrals.
The basic principle behind this rule is to approximate the area under the curve y = f(x), where f(x)
is the function, of which integral is to be evaluated, by a trapezoid. Of course, you know that the
integral of a function is nothing but the area between the function de- scribing the curve and the
x-axis.

The trapezoidal rule for approximating an integral is as follows (for details consult any numerical
analysis textbook):
74 C Programming & Data Structures

za f ( x) dx = h LM f (a) +2 f (b) + i ∑= 1 f ( xi )OP

b n−1

N Q
where

b−a
h= (ii)
n
and
i = 0, 1, 2, ..., n (iii)
Therefore, the algorithm to evaluate an integral using this method is simple. The user defines the
function within the integral, and inputs the values of the lower bound, a, the upper bound, b, and
the number of sampling points, n. Using these the value of h is calculated. Evaluating the right
hand side of Eqn (i) is a simple exercise. Here is an example which evaluates the integral

U /*Program to evaluate a definite integral using Trapezoidal Inte-

gration
The integral to be evaluated must be supplied in func(x)*/

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

double func(double x); //func(x) is the expression within

the integral to be e v a l u a t e d
int main()
{
int i; //loop counter
int n; //INPUT : number of subintervals
double a,b; //INPUT : boundaries of integral
double h; //Subinterval width
double sum = 0; //Approximate integral value
double x;

printf( “ \n” );
printf(“Enter the boundaries of the integral [a,b]\n”);
printf(“Example: a = -1 and b = 1, so type: -1 1: “);
scanf(“%lf %lf”,&a, &b);
printf(“The boundaries of the integral are: %lf %lf\n”,a, b);
printf( “ \n” );
printf(“Enter the number of subintervals: “);
scanf(“%d”,&M);
printf(“You said : %d subintervals.\n”,n);
h = (b - a) / n; //Subinterval width

//This loop evaluates the 2nd term on RHS of equation (i) above for
 Let’s C:A Supplement to Computer Programming Lab 75
( i = 1; i <= n-1; i++ )
{
x = a + h*i;
sum+ = func(x);
}
//The final approximate value of the integral using the Trapezoidal
Rule
sum = h * ( func(a) + func(b) + 2 * sum )/2;

printf( “  \n” );
printf(“ The approximate value of the integral of func(x)\n”);
printf(“ on the interval %lf %lf\n”, a,b);
printf(“ using %d subintervals computed using the
trapezoidal\n”,n);
printf(“ rule is : %lf\n”,sum);
printf(“ \n” );
return 0;
} // end main()
//sample definition of func
double func(double x)
{
return ( 1 / ( 1 + pow(x,2) ) ); }

Simpson’s Method

Simpson’s method is another numerical approximation technique for definite integrals. It con-
verges faster than the Trapezoidal method to the definite inte- gral represented by the approxima-
tion. However, in most cases the accuracy required is not more than a few decimal places. Hence
the two methods can be used interchangeably. Simpson’s method is as follows (Students interested
in details, such as rate of convergence and error in approximation, may con- sult any standard
textbook on numerical methods):

LM OP
za
b
f ( x ) dx =
h
3 N
n −1

i =1
n
( f (a ) + f (b)) + 2 ∑ f ( x2 i ) + 4 ∑ f ( x2 i ) − 1 (i)
i =1 Q
where

b−a
h= (ii)
2n
and
i = 0, 1, 2, …, n (iii)
As in the case of the Trapezoidal method, the evaluation of the integral is simple. Only two
summations have to be calculated. The following program uses Simpson’s method to evaluate a
definite integral. The example integral taken is:

za 1 +1x 2 dx
b
76 C Programming & Data Structures

U/* Program to evaluate a definite integral using Simpson s Method

Integral to be evaluated must be supplied in func(x)*/

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

double func(double x);

void main()
{
int i; // loop counter
int n; // INPUT : number of subintervals
double a,b; // INPUT : boundaries of integral
double h; // Subinterval width
double SumEven = 0; // approx. Even integral
double SumOdd = 0; // approx. Odd integral
double sum = 0; //approx. integral value
double x;
printf( “ \n” );
printf(“Enter the boundaries of the integral [a,b]\n”);
printf(“EXAMPLE: A = -1 and B = 1, so type: -1 1\n”);
scanf(“%lf %lf”,&a, &b);
printf(“The boundaries of the integral are: %lf %lf\n”,a, b);

printf( “ \n” );
printf(“Enter the number of SUBINTERVALS:”);
scanf(“%d”,&n);

printf(“You said : %d subintervals.\n”,n);

h = (b - a)/(2*n); // Subinterval width

/* Loop for even subscripts */
for ( i = 1; i <= n-1; i++ ) {
x = a + h * 2 * i;
SumEven = SumEven + func(x);
}

/* Loop for odd subscripts */

for ( i = 1; i <= n; i++ ) {

x = a + h*( 2 * i - 1);
SumOdd = SumOdd + func(x);
}
//Final value
sum = h * ( func(a) + func(b) + 2*SumEven + 4*SumOdd ) / 3;

printf( “ \n” );
printf(“ The approximate value of the integral of f(x)\n”);
printf(“ on the interval %lf %lf\n”, a,b);
printf(“ using %d subintervals computed using the Simpson’s\n”,2*n);
printf(“ Method is : %lf\n”,sum);
 Let’s C:A Supplement to Computer Programming Lab 77
printf( “ \n” );

}// main

//definition of integrand

double func(double x)
{
return ( 1 / ( 1 + pow(x,2) ) );
}