\( \def\bold#1{\bf #1} \newcommand{\d}{\mathrm{d}} \) BTP: Manual and Source Code Documentation

Power Uphill

bike mass [kg]
body mass [kg]
altitude gain [m]
climb length [km]
gradient [%]
time [s]
speed [km/h]
power [W]
power/mass [W/kg]
climbrate [m/min]

average power on climb stage

BTP  3.0
Routing/ClimbAnalysis/PowerCalculation
fibunacci.h
1 /*Prioritätswartelist, sortiert Elemente gemäß dem Float, der an erster Stelle
2 in ele->data[0] steht*/
3 #pragma once
4 #include <string> //c++-String-Klasse
5 #include <stdio.h> //C-File-Handling
6 #include <math.h>
7 #include "DataTyps.h"
8 
9 template <class T> class ele{
10 public:
11  ele();
12  ele(float d);
13  T* data; //mit Knoten verbundene Daten
14  ele<T> *l, *r, *next; //Blattstruktur
15  int m; //Markierung
16  float* d;
17 };
18 template <class T> ele<T>::ele(){
19 }
20 template<> ele<STRONGfib>::ele(float d);
21 template<> ele<STRONGPlusfib>::ele(float d);
22 template<> ele<CAfib>::ele(float d);
23 template <class T> class FibunacciHeap{
24  public:
25  FibunacciHeap();
26  ~FibunacciHeap();
27  T* ins(float d);
28  T* getmin();
29  T* extmin();
30  T* del(ele<T>* e);
31  private:
32  void clean();
33  ele<T>* m;
34  long int n;
35 };
36 template <class T> FibunacciHeap<T>::FibunacciHeap(){
37  m = NULL;
38  n = 0;
39 }
40 template <class T> FibunacciHeap<T>::~FibunacciHeap(){
41  if(m != NULL){
42  ele<T>* k;
43  ele<T> dummy;
44  m->l->r = &dummy;
45  while(m != &dummy && m != NULL){
46  if(m->next != NULL){
47  /*einfuegen der Kinder in die Wurzelliste*/
48  k = m->next;
49  k->l->r = m->r;
50  m->r->l = k->l;
51  k->l = m;
52  m->r = k;
53 
54  /*loeschen des Wurzelelements*/
55  k = m;
56  m = m->r;
57  delete k->data;
58  delete k;
59  }
60  else{
61  k = m;
62  m = m->r;
63  delete k->data;
64  delete k;
65  }
66  }
67  m = NULL;
68  }
69 }
70 template <class T> T* FibunacciHeap<T>::getmin(){
71  return m->data;
72 }
73 template <class T> T* FibunacciHeap<T>::ins(float d){
74  ele<T>* e = new ele<T>(d);
75  e->m = 0;
76  e->next = NULL;
77 
78  /*Einbinden in Wurzelliste*/
79  if(m != NULL){
80  e->l = m->l;
81  e->r = m;
82  m->l = e;
83  e->l->r = e;
84  if(*((float*)(m->data)) > d)
85  m = e;
86  }
87  else{
88  e->l = e;
89  e->r = e;
90  m = e;
91  }
92 
93  n++;
94  return e->data;
95 }
96 template <class T> T* FibunacciHeap<T>::extmin(){
97  if(m != NULL){
98  T* result = m->data;
99  /*alle Kinder in die Wurzelliste einfuegen*/
100  ele<T>* k = m->next, *b;
101  if(k != NULL)
102  k->l->r = NULL; //Listen aufbrechen
103  while(k != NULL){
104  k->l = m->l;
105  b = k->r; //naechstes Kind abfangen
106  k->r = m;
107  m->l = k;
108  k->l->r = k;
109  k = b;
110  }
111  /*altes min-Elemente ausklinken*/
112  m->l->r = m->r;
113  m->r->l = m->l;
114  b = m->r;
115  if(b != m){
116  /*falls noch Elemente im fibunacci-Heap vorhanden sind*/
117  delete m;
118  m = b;
119 
120  /*Liste aufraeumen, neues Minimalelement suchen*/
121  n--;
122  clean();
123  return result;
124  }
125  else{
126  delete m;
127  m = NULL;
128  n = 0;
129  return result;
130  }
131 
132  }
133  else
134  return NULL;
135 }
136 template <class T> void FibunacciHeap<T>::clean(){
137  if(n > 1){
138  /*Hilfsarray a[] anlegen, in das Unterbäume ihrem Grade/Markierung nach
139  eingeordnet werden*/
140  long int N = (long int) ceil(2*log((double)n));
141  ele<T>** a = new ele<T>*[N];
142  for(long int i = 0; i < N; i++)
143  a[i] = NULL;
144  /*Alle Wurzelemente in a[] einordnen*/
145  ele<T>* k = m;
146  k->l->r = NULL;
147  while(k != NULL){
148  if(a[k->m] == NULL){
149  /*Falls das Array an der Stelle k->m frei ist*/
150  a[k->m] = k;
151  k = k->r;
152  }
153  else{
154  /*an der Stelle k->m ist steht schon ein Baum*/
155  if(*((float*)a[k->m]->data) <= *((float*) k->data)){
156  /*der bestehende Baum hat einen kleineren Schluesselwert als
157  der einzuordnende Baum, der einzuordnende Baum wird Kind des
158  bestehenden*/
159  ele<T>* b = k->r;
160 
161  if(a[k->m]->next == NULL){
162  a[k->m]->next = k;
163  k->l = k;
164  k->r = k;
165  }
166  else{
167  k->l = a[k->m]->next->l;
168  k->r = a[k->m]->next;
169  k->l->r = k;
170  a[k->m]->next->l = k;
171  }
172 
173  if(a[k->m]->m < k->m + 1){
174  /*der bestehende Baum steht jetzt leider an der falschen
175  Stelle im Array, da sein Grad gewachsen ist, er muss neu
176  eingeordnet werden*/
177  a[k->m]->r = b; //damit alle noch einzuordnenden
178  //Wurzelelemente verarbeitet werden
179  a[k->m]->m = k->m + 1;
180  k = a[k->m];
181  a[k->m-1] = NULL;
182  }
183  else
184  /*sonst mit dem naechsten Wurzelelement fortfahren*/
185  k = b;
186  }
187  else{
188  /*der bestehende Baum hat einen groesseren Schluesselwert als
189  der einzuordnende Baum, der bestehende Baum wird Kind des
190  einzuordnenden Baum, der einzuordnende Baum bestetzt a[k->m]*/
191  if(k->next == NULL){
192  k->next = a[k->m];
193  a[k->m]->l = a[k->m];
194  a[k->m]->r = a[k->m];
195  }
196  else{
197  a[k->m]->l = k->next->l;
198  a[k->m]->r = k->next;
199  a[k->m]->l->r = a[k->m];
200  k->next->l = a[k->m];
201  }
202  if(a[k->m]->m + 1 > k->m){
203  /*der neu eingeordnete Baum steht jetzt leider an der
204  falschen Stelle im Array, da sein Grad gewachsen ist, er
205  muss neu eingeordnet werden*/
206  int b = k->m;
207  k->m = a[b]->m + 1;
208  a[b] = NULL;
209  }
210  else{
211  a[k->m] = k;
212  k = k->r;
213  }
214  }
215  }
216  }
217 
218  /*neue Wurzelliste zusammensetzen, nebenbei neues Minimalelement finden*/
219  m = NULL;
220  long int i = 0;
221  while(m == NULL){
222  if(a[i] != NULL)
223  m = a[i];
224  i++;
225  }
226  m->l = m;
227  m->r = m;
228  for(; i < N; i++)
229  if (a[i] != NULL){
230  a[i]->l = m->l;
231  a[i]->r = m;
232  a[i]->l->r = a[i];
233  a[i]->r->l = a[i];
234  if(*a[i]->d <* m->d)
235  m = a[i];
236  }
237  delete a;
238  }
239 }
Definition: fibunacci.h:9