proggen.org

Code: Alles auswählen

wunschGewicht = startGewicht * 0,98^Zeit

Code: Alles auswählen

log(0,98) (wunschGewicht/startGewicht) = Zeit
// 0,98 ist dabei die Basis und (wunschGewicht/startGewicht) der Nummerus

Code: Alles auswählen

int time;
while (wunschGew > Gewicht){
  Gewicht= 0.98*Gewicht;
  time++;
}

Code: Alles auswählen

[Parameter]
 Gewicht start       : 100.000000
 Gewicht ende        : 80.000000
 Prozentuale Abnahme : 2.000000
 Zeit bis erreichen  : 11.045229
 Durchläufe          : 1000000
[/Parameter]
[Ergebnisse]
 Dauer Logarithmus : 120000 clicks (0.120000 sec.)
 Dauer Schleife    : 100000 clicks (0.100000 sec.)
[/Ergebnisse]

[Parameter]
 Gewicht start       : 100.000000
 Gewicht ende        : 75.000000
 Prozentuale Abnahme : 2.000000
 Zeit bis erreichen  : 14.239779
 Durchläufe          : 1000000
[/Parameter]
[Ergebnisse]
 Dauer Logarithmus : 110000 clicks (0.110000 sec.)
 Dauer Schleife    : 130000 clicks (0.130000 sec.)
[/Ergebnisse]

Code: Alles auswählen

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

/*
	Benchmark: Log vs. Schleife
	(c) J.Sauer Dez. 2012 [Fisherman (==) proggen.org]
        Compile: cc ./speedtest.c -o speedtest -lm
        Test: ./speedtest > ./log.txt
*/


// Berechnung der Abnahmezeit mittels Logarithmus
float abnahmezeit_log(float start, float ende, float prozent)
{
 return (log(ende/start)/log((1-(prozent/100.0))));
}


// Berechnung der Abnahmezeit mittels Schleife
int abnahmezeit_schleife(float start, float ende, float prozent)
{
 int zeit = 0, tmp = start;
 while (tmp > ende)
 {
 tmp = (1-(prozent/100.0)) * tmp;
 ++zeit;
 }
 return (zeit);
}


// Test - Durchführung
void scenario(int iterationen, float gewicht_start, float gewicht_ende, float prozentsatz)
{
 clock_t t;
 int i;
 // Ausgabe der Parameter
 printf("[Parameter]\n");
 printf(" Gewicht start       : %lf\n",gewicht_start);
 printf(" Gewicht ende        : %lf\n",gewicht_ende);
 printf(" Prozentuale Abnahme : %lf\n", prozentsatz);
 printf(" Zeit bis erreichen  : %lf\n",abnahmezeit_log(gewicht_start, gewicht_ende, prozentsatz));
 printf(" Durchläufe          : %i\n",iterationen);
 printf("[/Parameter]\n");
 printf("[Ergebnisse]\n");
 // Abnahmezeit mit Log berechnen
 float erg_a;
 int erg_b;
 t = clock();
 for (i=0; i<iterationen;++i)
   erg_a = abnahmezeit_log(gewicht_start, gewicht_ende, prozentsatz);
 t = clock() - t;
 printf(" Dauer Logarithmus : %d clicks (%f sec.)\n",t,((float)t)/CLOCKS_PER_SEC);

 // Abnahmezeit mit Schleife berechnen
 t = clock();
 for (i=0; i<iterationen;++i)
   erg_b = abnahmezeit_schleife(gewicht_start, gewicht_ende, prozentsatz);
 t = clock() - t;
 printf(" Dauer Schleife    : %d clicks (%f sec.)\n",t,((float)t)/CLOCKS_PER_SEC);

 printf("[/Ergebnisse]\n\n");

}

int main()
{
 // Parameter
 int   it = 1000000;	// Iterationen
 float gs = 100.0;	// Startgewicht
 float ge =  90.0;	// Zielgewicht
 float pr =   2.0;	// Prozentuale Abnahme

 float gstop = 50.0;	// Stop Bedingung Gewicht

 while (ge > gstop) 
 {
  scenario(it,gs,ge,pr);// Test Durchführen
  ge = ge - 5.0;	// Gewicht um Wert verringern für neuen Test
 }
 return 0;
}

Code: Alles auswählen

Wenn Du Glück hast, liegen zwischen Deiner Messung 2 Ticks. Wenn Du Pech hast nur einer.
Wie groß ist CLOCKS_PER_SEC bei Dir? Das gibt entsprechend die ungefähre Genauigkeit der einzelnen Ticks an.

Code: Alles auswählen

#include <iostream>
#include <time.h>

using namespace std;

int main () {

    for(int i = 0; i < 10 ; i++) {

        int first_clock = clock();
        int first_time = time(NULL);

        while(time(NULL) <= first_time) {}

        int second_time = time(NULL);
        int second_clock = clock();

        cout << "Actual clocks per second = " << (second_clock - first_clock)/(second_time - first_time) << "\n";

        cout << "CLOCKS_PER_SEC = " << CLOCKS_PER_SEC << "\n";

    }

    return 0;

}

Code: Alles auswählen

Actual clocks per second = 940000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 1000000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 1000000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 1000000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 1000000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 990000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 990000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 1000000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 1010000
CLOCKS_PER_SEC = 1000000
Actual clocks per second = 1000000
CLOCKS_PER_SEC = 1000000