1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
| /* Biorythme.cpp : ce programme permet de faire afficher des informations sur le
* biorythme d'une personne dont la date de naissance et le nom sont gardés
* dans un fichier (on peut aussi les changer au besoin).
* Auteurs : M.M., complété par Carl-Éric Rouleau et Stéphane Lorion
* Création : novembre 2006
*/
#include <iostream>
#include <string>
#include <ctime>
#include <algorithm>
#include <cmath>
#include <cassert>
#include <algorithm>
using namespace std;
// Pour les divers calculs et saisies, on veut un intervalle d'années où les années
// bissextiles suivent le calendrier grégorien débuté au milieu de 1582 et qui est
// encore commun (pour le moment !)...
const int ANNÉE_MINIMUM= 1600;
const int ANNÉE_MAXIMUM= 2099;
// Les valeurs proposées pour la durée des trois cycles par les croyants de la biorythmie
const int DURÉE_CYCLE_PHYSIQUE= 23;
const int DURÉE_CYCLE_ÉMOTIONNEL= 28;
const int DURÉE_CYCLE_INTELLECTUEL= 33;
// Les divers caractères utilisés pour le dessin des courbes de biorythme et pour les axes
const char CARACTÈRE_POUR_BIORYTHME_ÉMOTIONNEL= 'e';
const char CARACTÈRE_POUR_BIORYTHME_INTELLECTUEL= 'i';
const char CARACTÈRE_POUR_BIORYTHME_PHYSIQUE= 'p';
const char CARACTÈRE_POUR_AXE_VERTICAL= '|';
const char CARACTÈRE_POUR_AXE_HORIZONTAL_SANS_DATE= '=';
const char CARACTÈRE_POUR_AXE_HORIZONTAL_AVEC_DATE= '-';
const char CARACTÈRE_POUR_INTERSECTION_DES_AXES= '+';
const int HAUTEUR_CYCLE_BIORYTHME= 9; // La hauteur du dessin, en haut et en bas du 0; devrait
// être moins que la moitié de la hauteur affichable
const int NB_JOURS_PRÉSENTÉS= 39; // Devrait être impair et moins que la moitié de la
// largeur affichable
const string FICHIER_INFO_NAISSANCE= "InfoNaissance.txt"; // Contiendra nom et date de
// naissance
/////////////////////////////////////////////////////////////////////////////////////////
// Pour aider à retrouver les fonctions de ce programme, on les a regroupées en deux
// sections, elles-mêmes subdivisées. La première section contient les fonctions les plus
// générales qui pourraient facilement être utiles dans d'autres programmes. En
// particulier, cette section contiendra des fonctions de saisie validée (une seule ici)
// et une groupe de fonctions de manipulations de dates. La deuxième section est
// constituée des fonctions plus spécifiques à ce programme : un groupe de fonctions
// s'occupent du calcul et du dessin des biorythmes, tandis que l'autre contient les
// fonctions de saisie et de sérialisation.
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
// FONCTIONS GÉNÉRALES : fonction(s) de saisie validée
/////////////////////////////////////////////////////////////////////////////////////////
/*****
* ObtenirEntier : permet d'obtenir une valeur entière dans l'intervalle demandé.
* La question indiquée est affichée, ainsi qu'un message d'erreur au besoin.
*/
int ObtenirEntier(string p_question, int p_minimum, int p_maximum)
{
cout << p_question;
int choix;
cin >> choix;
if(choix < p_minimum || choix > p_maximum)
cout << "*** Vous devez donner un nombre entre " << p_minimum << " et " << p_maximum << ".\n";
return choix;
}
/////////////////////////////////////////////////////////////////////////////////////////
// FONCTIONS GÉNÉRALES : fonctions de gestion des dates
/////////////////////////////////////////////////////////////////////////////////////////
void DéterminerDateCourante(int& p_s_jour, int& p_s_mois, int& p_s_année)
{
time_t t= time(0);
tm dateHeure= *localtime(&t);
p_s_jour= dateHeure.tm_mday;
p_s_mois= dateHeure.tm_mon + 1;
p_s_année= dateHeure.tm_year + 1900;
}
void AfficherDate(int p_année, int p_mois, int p_jour)
{
// Format standard aaaa-mm-jj, par exemple 2006-11-09
cout << p_année << "-" << p_mois << "-" << p_jour;
}
bool AnnéeBissextile(int p_année)
{
return p_année % 4 == 0
&& (p_année % 100 != 0 || p_année % 400 == 0);
}
int NbJoursAnnée(int p_année)
{
if (AnnéeBissextile(p_année))
return 366;
return 365;
}
/*****
* /*[...]*/
int NbJoursMois(int p_mois, int p_année)
{
if (p_mois == 2 && AnnéeBissextile(p_année))
return 29;
int nbJours; // À déterminer selon p_mois
switch (p_mois)
{
case 2 : nbJours= 28; break;
case 4 :
case 6 :
case 9 :
case 11 : nbJours= 30; break;
default : nbJours= 31; break;
}
return nbJours;
}
void ObtenirDate(string p_question, int&p_s_année, int& p_s_mois, int& p_s_jour)
{
p_question= ObtenirEntier("Votre choix : ", 0, 5);
p_s_année= ObtenirEntier("Année : ", 1600, 2099);
p_s_mois= ObtenirEntier("Numéro du mois : ", 1, 12);
p_s_jour= ObtenirEntier("Jour : ", 1, NbJoursMois(p_s_mois, p_s_année));
}
/*****
* CorrigerDate : Corrige la date en supposant que le jour et le mois peuvent être des
* valeurs invalides, ce qui pourrait aussi modifier l'année, qui n'est pas vérifiée.
*/
bool CorrigerDate(int& p_es_mois, int&p_es_année, int& p_es_jour)
{
if (/*[...]*/ && 1 <= /*[...]*/ <= NbJoursMois(p_es_mois, p_es_année))
return true;
// On corrige d'abord les erreurs possibles pour le mois
while (p_es_mois < 1)
{
--p_es_année;
p_es_mois+= 12;
}
while (p_es_mois > 12)
{
/*[...]*/
}
// On corrige ensuite les erreurs du jour en ajustant le reste au besoin
while (/*[...]*/)
{
if (p_es_mois != 1)
--p_es_mois;
else
{
--p_es_année;
p_es_mois= 12;
}
p_es_jour+= NbJoursMois(p_es_mois, p_es_année);
}
while (/*[...]*/ > NbJoursMois(p_es_mois, p_es_année))
{
p_es_jour-= /*[...]*/;
if (/*[...]*/)
++p_es_mois;
else
{
/*[...]*/
p_es_mois= 1;
}
}
return false;
}
/*****
* NoJourDansAnnée : renvoie le numéro du jour dans l'année, le premier janvier étant le
* numéro 1, le 2 janvier étant le 2 et ainsi de suite jusqu'au 31 décembre qui sera
* 365 ou 366 si l'année est bissextile (c'est pourquoi l'année est un paramètre).
*/
int NoJourDansAnnée(int p_année, int p_mois, int p_jour)
{
int noJour= p_jour; // On y ajoutera le décalage du début du mois
switch (p_mois)
{
case 1 : break;
case 2 : noJour+= 31; break;
case 3 : noJour+= 31+28; break;
case 4 : noJour+= 31+28+31; break;
case 5 : nbJour+= 31+28+31+30 break;
case 6 : noJour+= 31+28+31+30+31 break;
case 7 : noJour+= 31+28+31+30+31+30 break;
case 8 : noJour+= 31+28+31+30+31+30+31 break;
case 9 : noJour+= 31+28+31+30+31+30+31+31 break;
case 10 : noJour+= 31+28+31+30+31+30+31+31+30 break;
case 11 : noJour+= 31+28+31+30+31+30+31+31+30+31 break;
case 12 : noJour+= 31+28+31+30+31+30+31+31+30+31+30; break;
default : assert(false); break;
}
if (p_mois > 2 && AnnéeBissextile(année))
++noJour;
return noJour;
}
/*****
* /*[...]*/
int NbJoursEntreDates(int p_annéeDépart, int p_moisDépart, int p_jourDépart,
int p_annéeFin, int p_moisFin, int p_jourFin)
{
// On va commencer par vérifier si la date de départ est plus grande que la date de
// de fin. Dans ce cas, on va inverser les deux dates pour simplifier le calcul et on
// inversera le résultat à la fin.
bool inversé; // Indiquera si la date de départ est plus grande que la date de fin
if (p_annéeDépart != p_annéeFin)
inversé= p_annéeDépart > p_annéeFin;
else
if (p_moisDépart != p_moisFin)
inversé= p_moisDépart > p_moisFin;
else
inversé= p_jourDépart > p_jourFin;
if (inversé)
{
swap(p_annéeDépart, p_annéeFin);
swap(p_moisDépart, p_moisFin);
swap(p_jourDépart, p_jourFin);
}
// On calcule d'abord le nombre de jours entre la date de départ et la fin de son année
int nbJoursÉcart= NbJoursAnnée(p_annéeDépart)
- NoJourDansAnnée(p_annéeDépart, p_moisDépart, p_jourDépart);
// On ajoute les années entières pour les autres années jusqu'à la date de fin
for (int année= p_annéeDépart+1; année <= p_annéeFin; ++année)
nbJoursÉcart+= /*[...]*/;
// On retire le temps restant de l'année de fin
nbJoursÉcart-= NbJoursAnnée(p_annéeFin)
- NbJoursEntreDates(p_annéeFin, p_moisFin, p_jourFin);
if (/*[...]*/)
nbJoursÉcart= -nbJoursÉcart;
return
}
/////////////////////////////////////////////////////////////////////////////////////////
// FONCTIONS SPÉCIFIQUES : fonctions de calcul et dessin du biorythme
/////////////////////////////////////////////////////////////////////////////////////////
/*****
* ValeurBiorythme : renvoie la valeur du biorythme pour le nombre de jours et la longueur
* du cycle fournis. Les courbes de biorythme sont des courbes sinusoïdales, donc la
* valeur renvoyeé est entre -1.0 et 1.0 (pouvant ensuite être mise à l'échelle désirée).
*/
double ValeurBiorythme(double p_nbJoursVie, int p_duréeCycle)
{
// On a besoin de faire un modulo du nombre de jours par la durée du cycle, mais
// l'opérateur % ne s'applique que sur des entiers. On le calculera donc plutôt avec
// la fonction fmod (de <cmath>).
double jourDansCycle= fmod(/*[...]*/, /*[Voir livre, Annexe A]*/);
// Alternativement on aurait pu extraire la partie entière manuellement, l'utiliser
// dans un calcul avec % et ajouter ensuite la partie non entière :
//
// int noJour= static_cast<int>(p_nbJoursVie);
// double jourDansCycle= (noJour % p_duréeCycle)
// + (p_nbJoursVie - noJour); // Portion non entière
//
// La portion de cycle écoulée donne la portion de l'angle, calculée ici en radian
// car c'est ce qu'exige la fonction sin.
double angle= 2.0*3.141592653589793238 * /*[...]*//p_duréeCycle;
return sin(angle);
}
/*****
* EstSurCycle : indique si la coordonnée (p_nbJourVie, p_y) devrait contenir un point de
* la courbe selon la durée du cycle indiquée. La fonction doit faire une sorte
* d'arrondie ou d'approximation afin que la courbe tracée soit assez « jolie ».
*/
bool EstSurCycle(double p_nbJoursVie, int p_y, int p_duréeCycle)
{
// Calcul de la vraie position y de la courbe pour ce point p_x
double y= ValeurBiorythme(nbJoursVie, duréeCycle) * HAUTEUR_CYCLE_BIORYTHME;
// On veut renvoyer vrai si ce y est assez proche du p_y sur le dessin. La formule
// suivante tient compte du fait que les courbes les plus à pic ont le plus de trous
// si on est trop précis. Le .85 a été trouvé par expérimentation...
return abs(y - p_y) <= (0.85 - p_duréeCycle/100.0);
}
/*****
* AfficherLigneDeDates : fait afficher la ligne de date qui se trouvera normalement au
* dessus et au dessous du dessin du biorythme. Elle affiche un numéro de jour sur
* deux, la moitié des NB_JOURS_PRÉSENTÉS avant et l'autre moitié après la date
* désirée. Elle indique aussi la position de la date désirée par ||.
*/
void AfficherLigneDeDates(int p_annéeDésirée, int p_moisDésirée, int p_jourDésirée)
{
for (int noJour= -NB_JOURS_PRÉSENTÉS/2; noJour <= NB_JOURS_PRÉSENTÉS/2; ++noJour)
{
// Chaque jour fait afficher deux colonnes
if (noJour == 0)
cout << CARACTÈRE_POUR_AXE_VERTICAL << CARACTÈRE_POUR_AXE_VERTICAL;
else
if (noJour%2 == 0) // On affiche une date sur deux
/*[...]*/
else
{
int année= p_annéeDésirée;
int mois= p_moisDésirée;
int jour= p_jourDésirée + noJour;
CorrigerDate(année, mois, jour);
cout << /*[...]*/ << setfill(/*[...]*/);
}
}
/*[...]*/
}
/*****
* CaractèreDeBaseSelonPosition : renvoie le caractère devrait être dessiné à la position
* indiquée si le point n'est pas sur la courbe d'un biorythme. Les divers caractères
* renvoyés permettent de tracer les axes avec des repères pour les dates.
*/
char CaractèreDeBaseSelonPosition(int p_x, int p_y)
{
char dessin= ' ';
if (p_y == 0) // Sur l'axe horizontal...
{
if (p_x == 0)
dessin= /*[...]*/;
else
if (p_x % 2 == 0)
dessin= CARACTÈRE_POUR_AXE_HORIZONTAL_SANS_DATE;
else
dessin= CARACTÈRE_POUR_AXE_HORIZONTAL_AVEC_DATE;
}
else
if (p_x == 0) // Sur l'axe vertical...
dessin= /*[...]*/
return dessin;
}
/*******
* CaractèreSelonCycles : renvoie un caractère identifiant la courbe qui passe
* à la position indiquée, le cas échéant, sinon renvoie une espace. L'ordre
* des tests donne une sorte de priorité aux courbes si plusieurs se coupent
* à la même position (on a mis les tests en ordre alphabétique).
*/
char CaractèreSelonCycles(double p_nbJoursVie, int p_y)
{
char dessin= ' ';
if (p_nbJoursVie >= 0.0)
{
if (EstSurCycle(p_nbJoursVie, p_y, /*[...]*/))
dessin= CARACTÈRE_POUR_BIORYTHME_ÉMOTIONNEL;
else
if (/*[...]*/)
dessin= CARACTÈRE_POUR_BIORYTHME_INTELLECTUEL;
/*[...]*/
}
return dessin;
}
/*****
* /*[...]*/
void AfficherBiorythme(string p_nom,
int p_annéeNaissance, int p_moisNaissance, int p_jourNaissance,
int p_annéeDésirée, int p_moisDésirée, int p_jourDésirée)
{
int nbJoursVie= NbJoursEntreDates(p_annéeNaissance, p_moisNaissance, p_jourNaissance,
/*[...]*/);
cout << "BIORYTHME DE " << p_nom << " À " << nbJoursVie << " JOURS\n";
AfficherLigneDeDates(p_annéeDésirée, p_moisDésirée, p_jourDésirée);
for (int y= HAUTEUR_CYCLE_BIORYTHME; y >= -HAUTEUR_CYCLE_BIORYTHME; /*[...]*/)
{
for (int x= -NB_JOURS_PRÉSENTÉS/2; x <= NB_JOURS_PRÉSENTÉS/2; /*[...]*/)
{
// Deux colonnes par jour... des demi-journées...
for (int colonneDuJour= 0; /*[...]*/; ++colonneDuJour)
{
double nbJoursViePrécis= nbJoursVie + x + colonneDuJour*0.5;
// On choisit le caractère à dessiner selon les circonstances
char dessin= CaractèreSelonCycles(nbJoursViePrécis, y);
if (dessin == ' ')
dessin= CaractèreDeBaseSelonPosition(x, y);
cout << dessin;
}
}
cout << '\n';
}
/*[...]*/
cout << setw(NB_JOURS_PRÉSENTÉS+1) << /*[...]*/
<< setw(NB_JOURS_PRÉSENTÉS-5) << ' ';
/*[...]*/
cout << "\n"
"Tapez Entrée pour retourner au menu...";
cin.ignore();
}
/*****
* /*[...]*/
/*[...]*/
{
cout << "\n"
<< "SCORES DU BIORYTHME DE " << p_nom << " POUR LE ";
AfficherDate(p_annéeDésirée, p_moisDésirée, p_jourDésirée);
cout << '\n';
cout << "Date de naissance : ";
AfficherDate(p_annéeNaissance, p_moisNaissance, p_jourNaissance);
cout << '\n';
/*[...]*/
cout << "Nombre de jours de vie : " << /*[...]*/
/*[...]*/
<< (100 * ValeurBiorythme(nbJoursVie, DURÉE_CYCLE_INTELLECTUEL)) << " %\n";
}
/*[...]*/
/////////////////////////////////////////////////////////////////////////////////////////
// FONCTIONS SPÉCIFIQUES : fonctions de manipulation des données (sérialisation et saisie)
/////////////////////////////////////////////////////////////////////////////////////////
/*****
* RécupérerInfoNaissance : désérialise le nom et la date de naissance de l'utilisateur
* courant du programme. Renvoie faux si les données n'ont pas été récupérées, en
* principe parce que c'est la première utilisation et que le fichier n'existe pas.
*/
/*[...]*/
/*****
* EnregistrerInfoNaissance : sérialise le nom et la date de naissance de l'utilisateur
* courant du programme.
*/
/*[...]*/
string ObtenirInfoUtilisateur(string& p_s_nom, int& p_s_année, int& p_s_mois, int& p_s_jours)
{
cout << "Votre nom : ";
string nom;
cin >> p_s_nom;
cout << "Donnez votre date de naissance : ";
int p_s_année;
cout << "Année : ";
cin >> p_s_année;
int p_s_mois;
cout << "Numéro du mois : ";
cin >> p_s_mois;
int jour;
cout << "Jour : ";
cin >> p_s_jour;
}
/*****
* PROGRAMME PRINCIPAL
*/
int main()
{
string nom; // Les quatre données à désérialiser, si ce n'est pas
int annéeNaissance; // possible, on demandera simplement les valeurs à
int moisNaissance; // à l'utilisateur
int jourNaissance; //
if (/*[...]*/)
ObtenirInfoUtilisateur(nom, annéeNaissance, moisNaissance, jourNaissance);
int annéeCourante; // Formeront la date de base pour l'affichage des biorythmes
int moisCourant; //
int jourCourant; //
DéterminerDateCourante(annéeCourante, moisCourant, jourCourant);
for(;
{
cout << '\n'
<< "BIORYTHMIE POUR " << nom << '\n'
<< "1- Afficher le biorythme autour de la date courante (";
AfficherDate(année, mois, jour)
cout << ")\n"
"2- Afficher les scores en pourcentage pour la date courante\n"
"3- Avancer la date courante de deux semaines\n"
"4- Afficher le biorythme pour une autre journée\n"
"5- Changer de personne\n\n"
"0- Quitter\n\n";
int choix= ObtenirEntier("Votre choix : ", 0, 5);
/***/
/*[...]*/
switch (choix)
{
/*[...]*/
case 3 :
/*[...]*/
CorrigerDate(annéeCourante, moisCourant, jourCourant);
break;
case 4 :
AfficherBiorythmeAutreDate(nom, annéeNaissance, moisNaissance, jourNaissance);
break;
case 5 :
/*[...]*/
break;
}
}
/*[...]*/
} |
