clock_t problems

This is a discussion on clock_t problems within the C++ Programming forums, part of the General Programming Boards category; hi all I'm trying to build a couple of algorithms here for, my advanced data structures course and get the ...

  1. #1
    Registered User
    Join Date
    Apr 2003
    Posts
    78

    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 )
    {
          double answer;
          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++ )
                      {
                      answer = lastButOne + lastValue;
                      lastButOne = lastValue;
                      lastValue = answer;
                      counter++;
                      }
              }
    return answer;
    }
    /****************************************************************
     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. #2
    Frequently Quite Prolix dwks's Avatar
    Join Date
    Apr 2005
    Location
    Canada
    Posts
    8,046
    clock() is always zero the first time you call it.
    dwk

    Seek and ye shall find. quaere et invenies.

    "Simplicity does not precede complexity, but follows it." -- Alan Perlis
    "Testing can only prove the presence of bugs, not their absence." -- Edsger Dijkstra
    "The only real mistake is the one from which we learn nothing." -- John Powell


    Other boards: DaniWeb, TPS
    Unofficial Wiki FAQ: cpwiki.sf.net

    My website: http://dwks.theprogrammingsite.com/
    Projects: codeform, xuni, atlantis, nort, etc.

  3. #3
    Frequently Quite Prolix dwks's Avatar
    Join Date
    Apr 2005
    Location
    Canada
    Posts
    8,046
    What's CLK_TCK? Is it like CLOCKS_PER_SECOND?
    dwk

    Seek and ye shall find. quaere et invenies.

    "Simplicity does not precede complexity, but follows it." -- Alan Perlis
    "Testing can only prove the presence of bugs, not their absence." -- Edsger Dijkstra
    "The only real mistake is the one from which we learn nothing." -- John Powell


    Other boards: DaniWeb, TPS
    Unofficial Wiki FAQ: cpwiki.sf.net

    My website: http://dwks.theprogrammingsite.com/
    Projects: codeform, xuni, atlantis, nort, etc.

  4. #4
    Registered User
    Join Date
    Apr 2003
    Posts
    78

    Whoa Whoa Whoa

    Anyone , Anyone
    Last edited by drdodirty2002; 09-24-2005 at 03:39 PM.

  5. #5
    and the hat of wrongness Salem's Avatar
    Join Date
    Aug 2001
    Location
    The edge of the known universe
    Posts
    32,485
    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
    If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
    If at first you don't succeed, try writing your phone number on the exam paper.
    I support http://www.ukip.org/ as the first necessary step to a free Europe.

  6. #6
    Registered User
    Join Date
    Aug 2005
    Posts
    10
    Quote 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

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. No clue how to make a code to solve problems!
    By ctnzn in forum C Programming
    Replies: 8
    Last Post: 10-16-2008, 02:59 AM
  2. String Manipulation problems -_-
    By Astra in forum C Programming
    Replies: 5
    Last Post: 12-13-2006, 04:48 PM
  3. Rendering problems (DirectX?)
    By OnionKnight in forum Tech Board
    Replies: 0
    Last Post: 08-17-2006, 12:17 PM
  4. contest problems on my site
    By DavidP in forum Contests Board
    Replies: 4
    Last Post: 01-10-2004, 08:19 PM
  5. DJGPP problems
    By stormswift in forum C Programming
    Replies: 2
    Last Post: 02-26-2002, 03:35 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21