1. ## clock_t problems

hi all I'm trying to build a couple of algorithms here for, my advanced data structures course and get the run times however I cant seem to get the clock_t variables to output to the screen at all. check the code
Code:
```#include<iostream>
#include<fstream>
#include<iomanip>
#include <time.h>
using namespace std;

/**************************************************************

PURPOSE:

The algorithm works iterativley it takes an input n it
then calculates the fibonacci sequence up to that number
by adding LastButOne's values and lastValue over and
over again until the value of "i" is equal to that of
the value of "n". At this point the loop terminates
and no longer calculates any more numbers in
the fibonacci series. Since the algorithm is
being increased by a constant value the growth rate for
this algorithm is Big O(N)

IteratFib
DATA TABLE:

n          = input for the function to calculate up to the nth fibonacci
LastValue  = the F(n-1) value to be added
lastButone = the F(n-2) value to be added
i          = The current number to be calculated starting at 2
counter    = the number of iterations required to complete
answer     = the actual calculation of the nth fibonacci number
start      = a clock t variable to start the timer in each iteration of both
algorithms
finish		= a clock t variable to get the end time of each iteration
/***************************************************************/
double IteratFib(double n, double &counter )
{
if( n == 0 || n == 1 )
return n;
else
{
double lastButOne = 0;
double lastValue = 1;

//for loop to take n and compare it the
//variable j. If j is less than that number
//the loop then iterates and adds makes the
//variable answer equal to LastButOne + lastValue
//it then makes LastButone = Last Value or
//the Fn-2 it then makes lastValue = Currnent
//or  Fn-1. These values are saved in each of
//these variables to calculate the Fn Fibonacci
//number for. It will do this until "n" is
//greater than "i". It then exits the loop
//and returns the calculated value of the nth
//Fibonacci number The loop will do this u
//the requested fibonacci number

for( int i = 2; i <= n; i++ )
{
lastButOne = lastValue;
counter++;
}
}
}
/****************************************************************
PURPOSE:

this is the second version of the fibonacci series
calculation. This is the recursive version of the
program. This function is designed to go up to the
nth value which in shis case is 128. The implementation
of the program works by solving two previous instances of
itself. In this case it is the previous two numbers that
are two be added to equal the current fibonacci number.
For instance if you would like the fifth fibonacci number
it would be obtained by calculating 0,1,1,2,3. So in
essence the fifth fibonacci number is obtained by adding
the 3rd and the 4th numbers in that series. So the problem
doubles each time it is called and you end up with a growth
rate that is Big O(2^n) power or an exponential growth rate.

fibonacci()
DATA TABLE:

num          = the value that is being used as the base case
count        = the number of iterations for the function

/******************************************************************/

double fibonacci(double num, double &counter)
{
counter++;
//The first if statement is the base case for this program
//which checks to see if the number entering the algorithm
//is either one or zero. If it is either value it will then
//return that number since the Fibonacci of one or zero is
//itself. This is the case that will terminate the recusive
//calls back to the algorithm.

if(num==0 || num ==1)
{
counter++;
return num;
}
//the other case is if the number is greater than zero or one
//it then returns the number minus + the number minus two or
//the Fn = Fn-1 + Fn-2.
else
{

return fibonacci(num - 1, counter) + fibonacci(num  - 2, counter);
}
}

void main()
{
/******************************************************************
main
DATA TABLE:

j         = variable being used to determine whether the nth fib
counter   = the number of iterations that are required for each
iteratOut = an ofstream variable to output to text file name "iterout.txt"
outfile   = an ofstream variable to output to text file named "outfile.txt"
m         = this variable is to store the calculation of "fibonacci"
temp	   = this variable is to store temporary variables when the user enters
a one to start the series of both algorithms
*******************************************************************/

ofstream outfile;
outfile.open("output.xls", ios::out);
ofstream iteratOut;
iteratOut.open("iteratData.xls", ios::out);
double m;
double counter = 0;
int temp;
clock_t start, finish;
double duration;

cout<<"This is the iterative version of the Fibonacci Calculation: "<<endl;
cout<<endl<<endl;
cout<<"Enter '1' to begin: "<<endl;
cout<<"From 1-128: "<<endl<<endl;
cin>>temp;

if(temp!=1)
temp=1;
//this first for loop is designed to start at 1 and
//go up to the 128th fibonacci number using an
//iterative fibonacci calculation

for (double j=1; j<=128; j++)
{

//initialize counter to zero
cout<< "F(" << j << ") = " <<setw(20)<<setiosflags(ios::left);

start=clock();
m=IteratFib(j,counter);
finish=clock();
duration = (double)(finish - start)/CLK_TCK;

//output the result of the nth fibonacci number
cout      << fixed<<setprecision(2)<<m;

//output that to the screen as well as the counter
cout      << "\t" << counter <<"  Time elapsed : ";
cout		 <<duration<< "\n";

//now output those countents to the file
iteratOut << "F("<<j<< ")=" <<setw(20)<<setiosflags(ios::left);
iteratOut << fixed<<setprecision(2)<<m;
iteratOut << "\t" << counter << "\t"<<duration<<"\n";
counter=0;
}

//close text file
iteratOut.close();
cout    <<endl<<endl;
//output to screen
cout    << "This is the Recursive version of fibonacci:  "<<  endl;
//output to file
outfile << "RUN TIME AND ANALYSIS OF A RECURSIVE FIBONACCI ALGORITHM"
<<  endl;
outfile << "FROM 1 TO 128"<<endl;
cout    << "Enter '1' to begin:  ";

//request user to start the sequence of in the recursive version fibonacci()
cin     >> j;
//if else statement user enters something other than 1
if(j!=1)
j=1;
else
{
while(j<=128)
{              //initialize counter to zero for next iteration
counter=0;

//make "m" the value of the nth fibonacci
m=fibonacci(j, counter);

//output that value to the screen
cout   <<"The fibonacci of "<<setprecision(0)<<fixed<<j<<" is "<<m <<endl;

//output the number of calls required to do recursive algorithm
cout   <<"The total number of recursive calls to achieve fibonacci of "
<< counter <<" is "  <<counter<<endl;

//output the value and the number of iterations
outfile   <<"F("<<j<<")= "<<m<<"\t"
<<"ITERATIONS"<<"\t"<<counter<<endl;

//add one to "j" and get the next version of fibonacci
++j;

}
}
//close output file
outfile.close();
//end programs
}```
the problem is located in the first loop in the main. Every time I output the variable duration to the screen it shows up as zero. I did a debug on it and according that it shows a value for start and finish. So what is the deal here.

2. clock() is always zero the first time you call it.

3. What's CLK_TCK? Is it like CLOCKS_PER_SECOND?

4. ## Whoa Whoa Whoa

Anyone , Anyone

5. Probably because your code takes so little time to run that the clock never gets time to tick to anything meaningful.

If you want a real high-resolution timer, then look up QueryPerformanceCounter

6. Originally Posted by dwks
clock() is always zero the first time you call it.
That is incorrect. clock() may return 0 if you call it at the begining of your program, since it returns the amount of ticks since the program has started, but it certainly won't return 0 otherwise:

clock
Syntax:
Code:
```  #include <time.h>
clock_t clock( void );```
The clock() function returns the processor time since the program started, or -1 if that information is unavailable. To convert the return value to seconds, divide it by CLOCKS_PER_SEC. (Note: if your compiler is POSIX compliant, then CLOCKS_PER_SEC is always defined as 1000000.)
http://www.cppreference.com/stddate/clock.html