Operating system

1. DEPARTMENT OF INFORMATION SCIENCE
Fibonacci series using pthreads
Presented By-
ROHAN H RAJ 1BI20IS071
RAKSHITHA S 1BI20IS070
RUDRA MRIGNAK 1BI20IS072
SAGAR GHOSH 1BI20IS073
Faculty In charge:
Dr. Hema Jagadish
Associate Professor
Dept of ISE, BIT, Bangalore
BANGALORE INSTITUTE OF TECHNOLOGY

2. Fibonacci program in c pthread
 In a Fibonacci series, every number (except the first two numbers) is the sum of
the previous two numbers.The mathematical formula for a Fibonacci series is:
 F(n) = F(n - 1) + F(n - 2)F(n)=F(n−1)+F(n−2)
 Here, F(n) represents the n^{th}nth Fibonacci number.

3.  In Java, we can use different techniques like recursion and memoization to
create a Fibonacci series. Let us take a look at a few examples to understand
how can we create the Fibonacci series.

4.  Example 1
Fibonacci series using recursion in Java To calculate the Fibonacci series using
we need to create a function so that we can perform recursion. This function
input. The function checks whether the input number is 0, 1, or 2, and it
respectively, if the input is any one of the three numbers. If the input is greater
function calls itself recursively for the previous values until the value of the input
becomes less than or equal to 2. So if the function receives an integer n as input,
the n^th^ Fibonacci number. To print the Fibonacci series we will call this
each Fibonacci number.

5. public class FibonacciCalc
{
public static int fibRecursion(int count)
{
if (count == 0)
{
return 0;
}
if (count == 1 || count == 2)
{
return 1;
}return fibRecursion(count - 1) + fibRecursion(count - 2);
}
public static void main(String args[])
{
int fib_len = 9;
System.out.print("Fibonacci Series of " + fib_len + " numbers is:
n");
for (int i = 0; i < fib_len; i++)
{
System.out.print(fibRecursion(i) + " ");
}
}
}

6. Output of the program:
Fibonacci Series of 9 numbers is: 0 1 1 2 3 5 8 13 21

7. In the above example, we defined a recursive function fib Recursion to get nth Fibonacci
number and call it repeatedly (for i=0 to i=8) in order to create a Fibonacci series of length
9.

8. Implementation in C
#include <pthread.h>
#include <stdio.h>
int fib;/* this data is shared by the thread(s) */
void *runner(void *param); /* the thread */
int main(int argc, char *argv[])
{ pthread_t tid; /* the thread identifier */
pthread_attr_t attr; /* set of attributes for the thread */
if (argc != 2)
{
fprintf(stderr,"usage: a.out <integer value>n");
return -1;
}
if (atoi(argv[1]) < 0)
{
fprintf(stderr,"Argument %d must be non-negativen",atoi(argv[1]));
return -1;
}
/* get the default attributes */
pthread_attr_init(&attr);
/* create the thread */
pthread_create(&tid,&attr,runner,argv[1]);
/* now wait for the thread to exit */
pthread_join(tid,NULL);
printf("Fibonacci = %dn",fib);
}

9. if (atoi(argv[1]) < 0)
{
fprintf(stderr,"Argument %d must be non-negativen",atoi(argv[1]));
return -1;
}
/* get the default attributes */
pthread_attr_init(&attr);
/* create the thread */
pthread_create(&tid,&attr,runner,argv[1]);
/* now wait for the thread to exit */
pthread_join(tid,NULL);
printf("Fibonacci = %dn",fib);
}
void *runner(void *param)
{
int i, upper = atoi(param);
fib= 1;
if (upper > 0)
{
int pre1 = 0;
int pre2 = 1;
int current ;
if (fib == 1)

10. {
printf("The Fibonacci sequence for the number you entered is n");
printf("%dn",pre1);
exit(0);
}
else if (fib == 2)
{
printf("The Fibonacci sequence for the number you entered is n");
printf("%d , %dn",pre1 ,pre2 );
exit(0);
}
else { int j=3;
printf(" nThe Fibonacci sequence for the number you entered is n %d , %d ,",pre1,pre2 );
for(j = 3; j <= fib; j++)
{
current = pre2 + pre1;
pre1 = pre2;
pre2 = current;
printf(" %d ,",current)
}
}
}
pthread_exit(0);
}
*/ ("Foon");

11. Output

12. Time And Space Complexity
The time complexity of the recursive approach to solving the
is O(2^n)O(2n) i.e. exponential time. The space complexity of the
method is O(n), if we consider the recursive stack.
Exponential time complexity is extremely inefficient. It would take
calculate the Fibonacci series of a huge length using the recursive
solve this problem, we can use the memorization technique to
Fibonacci series. This technique is much faster than the recursive

13. CONCLUSIO
Here, we have seen how to build the concurrent application for
Fibonacci series.

14. THANKYOU