Differences
This shows you the differences between two versions of the page.
|
programare:laboratoare:lab02 [2025/10/10 11:17] darius.neatu |
programare:laboratoare:lab02 [2025/10/10 19:47] (current) darius.neatu [PCLP Laborator02: Tipuri de date. Operatori. Instrucțiunile limbajului C] |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ===== Tipuri de date. Operatori. Functii matematice. ===== | + | ===== PCLP Laborator02: Tipuri de date. Operatori. Instrucțiunile limbajului C ===== |
| + | |||
| + | **Responsabili:** | ||
| + | * [[neatudarius@gmail.com|Darius Neațu (2019 - prezent)]] | ||
| + | * [[ion_dorinel.filip@cti.pub.ro|Dorinel Filip (2019 - prezent)]] | ||
| + | * [[teodor.matei.birleanu@gmail.com|Bîrleanu Teodor Matei (2025 - prezent)]] | ||
| + | * [[rares96cheseli@gmail.com|Rareș Cheșeli (2017)]] | ||
| + | * [[calin.cruceru@cti.pub.ro|Călin Cruceru (2015)]] | ||
| + | * [[emil.racec@gmail.com|Emil Racec (2014, 2012)]] | ||
| + | * [[bogdandrutu@gmail.com|Bogdan-Cristian Drutu (2010)]] | ||
| + | * [[octavian.rinciog@gmail.com|Octavian Rînciog (2010)]] | ||
| + | |||
| ==== Obiective ==== | ==== Obiective ==== | ||
| Line 8: | Line 20: | ||
| * măsoare timpul de execuție al programelor scrise | * măsoare timpul de execuție al programelor scrise | ||
| * utilizeze funcțiile matematice din C | * utilizeze funcțiile matematice din C | ||
| + | * scrie programe C utilizând structuri condiţionale si de repetiţie | ||
| - | ==== Noţiuni teoretice ==== | ||
| - | === Tipuri fundamentale de date === | + | ==== Tipuri fundamentale de date ==== |
| Tipurile de date reprezintă tipul de informație care poate fi stocat într-o variabilă. Un tip de data definește atât gama de valori pe care o poate lua o variabilă de un anume tip cât și operațiile care se pot efectua asupra ei. În continuare sunt prezentate tipurile fundamentale ale limbajului C, împreună cu o scurtă descriere a acestora: | Tipurile de date reprezintă tipul de informație care poate fi stocat într-o variabilă. Un tip de data definește atât gama de valori pe care o poate lua o variabilă de un anume tip cât și operațiile care se pot efectua asupra ei. În continuare sunt prezentate tipurile fundamentale ale limbajului C, împreună cu o scurtă descriere a acestora: | ||
| Line 53: | Line 65: | ||
| Determinarea corectă a tipurilor de date care vor fi folosite este esențială pentru securitatea și buna funcționare a aplicațiilor pe care le scrieți. În cazul în care valoarea conținută de o variabilă depașește limitele impuse de tipul de date folosit, se produce așa-numit-ul over-flow care poate cauza erori aparent inexplicabile. (//Ca o anecdotă, în fiecare an (până acum trei sau patru ani), Bill Gates primea de la FISC o scrisoare prin care era somat să iși platească taxele, deoarece apărea in evidențele lor ca având datorii însemnate. Asta deoarece valoarea averii lui (mult peste 4.000.000.000$) producea un overflow în softul folosit de către FISC. În final situația a fost soluționată, introducând un câmp special pentru el în softul folosit. (A modifica softul peste tot ar fi introdus un plus de stocare nejustificat pentru fiecare din cei aproximativ 300.000.000 de cetațeni ai SUA.)// ) | Determinarea corectă a tipurilor de date care vor fi folosite este esențială pentru securitatea și buna funcționare a aplicațiilor pe care le scrieți. În cazul în care valoarea conținută de o variabilă depașește limitele impuse de tipul de date folosit, se produce așa-numit-ul over-flow care poate cauza erori aparent inexplicabile. (//Ca o anecdotă, în fiecare an (până acum trei sau patru ani), Bill Gates primea de la FISC o scrisoare prin care era somat să iși platească taxele, deoarece apărea in evidențele lor ca având datorii însemnate. Asta deoarece valoarea averii lui (mult peste 4.000.000.000$) producea un overflow în softul folosit de către FISC. În final situația a fost soluționată, introducând un câmp special pentru el în softul folosit. (A modifica softul peste tot ar fi introdus un plus de stocare nejustificat pentru fiecare din cei aproximativ 300.000.000 de cetațeni ai SUA.)// ) | ||
| - | === Operatori === | + | ==== Operatori ==== |
| Operatorii limbajului C pot fi unari, binari sau ternari, fiecare având o precedenţă şi o asociativitate bine definite. Tabelul următor sintetizează operatorii limbajului C. Operatorii sunt prezentaţi în ordine descrescătoare a priorităţii. | Operatorii limbajului C pot fi unari, binari sau ternari, fiecare având o precedenţă şi o asociativitate bine definite. Tabelul următor sintetizează operatorii limbajului C. Operatorii sunt prezentaţi în ordine descrescătoare a priorităţii. | ||
| Line 127: | Line 139: | ||
| Compilatorul consideră condiţia corectă, deoarece este o expresie validă în limbajul C care face atribuire, care se evaluează mereu la o valoare nenulă. | Compilatorul consideră condiţia corectă, deoarece este o expresie validă în limbajul C care face atribuire, care se evaluează mereu la o valoare nenulă. | ||
| - | === Funcții matematice === | + | ==== Funcții matematice ==== |
| Fișierul antet ''math.h'' conține un set de funcții matematice des utilizate în programe. Câteva dintre acestea sunt: | Fișierul antet ''math.h'' conține un set de funcții matematice des utilizate în programe. Câteva dintre acestea sunt: | ||
| Line 217: | Line 229: | ||
| </spoiler> | </spoiler> | ||
| - | <hidden> | + | ==== Instrucţiuni ==== |
| - | ==== Exerciții Laborator CB/CD ==== | + | |
| - | - Ne dorim să înțelegem tipurile de date. Acest exercițiu presupune rularea mai multor secvențe de cod cu scopul de a clarifica diverse aspecte. Analizați fiecare secvență și încercați să intuiți output-ul acesteia. După aceea verificați. | + | === Instrucţiuni condiţionale === |
| - | * <code c ex1a.c> | + | |
| - | #include <stdio.h> | + | |
| - | int main(void) { | + | == If-else == |
| - | char x = 65; | + | |
| - | + | ||
| - | printf("%u\n", x); | + | |
| - | printf("%c\n", x); | + | |
| - | printf("%d\n", x); | + | |
| - | return 0; | + | ''if...else'' este cea mai simplă instrucţiune condiţională. Poate fi folosită în mai multe forme: |
| + | |||
| + | <code c> | ||
| + | if (condition) { | ||
| + | // instructions | ||
| + | //... | ||
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1b.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | <code c> |
| - | char x = 130; | + | if (condition) { |
| - | + | // instructions | |
| - | if (x > 0) | + | // ... |
| - | printf("I'm positive!\n"); | + | } else { |
| - | else | + | // other instructions |
| - | printf("Not sure...\n"); | + | // ... |
| - | + | ||
| - | return 0; | + | |
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1c.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | <code c> |
| - | unsigned char x = 130; | + | if (condition1) { |
| - | + | ... | |
| - | if (x > 0) | + | } else if (condition2) { |
| - | printf("I'm positive!\n"); | + | ... |
| - | else | + | } |
| - | printf("Not sure...\n"); | + | ... |
| - | + | else if (conditionN) { | |
| - | return 0; | + | ... |
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1d.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | Instrucţiunea evaluează expresia ''condition'' şi execută instrucţiunile dintre acolade doar dacă rezultatul este nenul. În varianta cu ''else'', pentru rezultat nul este executat blocul de instrucţiuni aflat după ''else''. |
| - | char x = 321; | + | |
| - | + | ||
| - | printf("%u\n", x); | + | |
| - | printf("%c\n", x); | + | |
| - | printf("%d\n", x); | + | |
| - | return 0; | + | În al treilea caz, sunt evaluate pe rând condiţiile şi este executat blocul corespunzător primei condiţii adevărate. Un exemplu de folosire este: |
| + | |||
| + | <code c> | ||
| + | if (a == b) { | ||
| + | printf("Numerele sunt egale"); | ||
| + | } else if (a > b) { | ||
| + | printf("A este mai mare"); | ||
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1e1.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | == Switch == |
| - | unsigned int x = ~0; | + | |
| - | + | ||
| - | printf("%u\n", x); | + | |
| - | printf("%u\n", x + 1); | + | |
| - | return 0; | + | ''switch'' este o instrucţiune menită să simplifice structurile condiţionale cu mai multe condiţii. |
| + | |||
| + | <code c> | ||
| + | switch (expression) { | ||
| + | case constant1: | ||
| + | // instructions1 | ||
| + | case constant2: | ||
| + | // instructions2 | ||
| + | ... | ||
| + | default: | ||
| + | // instructions | ||
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1e2.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | Valoarea ''expression'' este evaluată la un tip intreg, apoi această valoare este comparată cu fiecare constantă; este rulat blocul de instrucţiuni al valorii găsite. În caz ca numărul nu este egal cu nici una dintre constante, este executat blocul aflat după ''default''. |
| - | unsigned int x = ~0; | + | |
| - | + | ||
| - | printf("%d\n", x); | + | |
| - | printf("%d\n", x + 1); | + | |
| - | return 0; | + | <note important> |
| + | După executarea ultimei instrucţiuni dintr-un bloc ''case'', execuţia nu continua după blocul ''switch'', ci la inceputul următorului bloc ''case //constant//'' sau ''default''. Pentru a ieşi din blocul ''switch'', se foloseşte instrucţiunea ''break''. | ||
| + | </note> | ||
| + | |||
| + | <code c> | ||
| + | int main() { | ||
| + | char c; | ||
| + | printf("Alegeţi o opţiune:\n\t[a] afişare\n\t[s] ştergere\n\t[e] ieşire\n"); | ||
| + | scanf("%c", &c); | ||
| + | printf("Aţi ales: "); | ||
| + | |||
| + | switch (c) { | ||
| + | case 'a': | ||
| + | printf("afişare"); | ||
| + | break; | ||
| + | |||
| + | case 's': | ||
| + | printf("ştergere"); | ||
| + | break; | ||
| + | |||
| + | case 'e': | ||
| + | printf("ieşire"); | ||
| + | break; | ||
| + | |||
| + | default: | ||
| + | printf("O opţiune inexistentă"); | ||
| + | break; | ||
| + | } | ||
| + | return 0; | ||
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1e3.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | <code c> |
| - | int x = ~0; | + | int main() { |
| - | + | int n, n2; | |
| - | printf("%u\n", x); | + | printf("Introduceţi o valoare între 0 şi 5:"); |
| - | printf("%u\n", x + 1); | + | scanf("%d", &n); |
| - | + | n2 = 1; | |
| - | return 0; | + | switch (n) { |
| + | case 5: | ||
| + | n2 *= 2; | ||
| + | /* fără break, continuă la următoarea instrucţiune */ | ||
| + | case 4: | ||
| + | n2 *= 2; | ||
| + | case 3: | ||
| + | n2 *= 2; | ||
| + | case 2: | ||
| + | n2 *= 2; | ||
| + | case 1: | ||
| + | n2 *= 2; | ||
| + | case 0: | ||
| + | printf("2 la puterea %d este %d\n", n, n2); | ||
| + | break; | ||
| + | |||
| + | default: | ||
| + | printf( "Valoare invalidă\n" ); | ||
| + | } | ||
| + | return 0; | ||
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1f1.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | === Instrucţiuni de repetiţie === |
| - | char x = -1; | + | |
| - | int y = x; | + | |
| - | printf("%u\n", x); | + | == while == |
| - | printf("%u\n", y); | + | |
| - | char a = 1; | + | ''while'' execută un bloc de instrucţiuni atâta timp cât o anumită condiţie este adevărată. Forma generală a unui ciclu while este: |
| - | int b = a; | + | |
| - | printf("%u\n", a); | + | <code c> |
| - | printf("%u\n", b); | + | while (expression) { |
| - | + | // instructions | |
| - | return 0; | + | |
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1f2.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | Câtă vreme ''expression'' are o valoare nenulă, instrucţiunile din blocul de după ''while'' sunt executate. Expresia este reevaluată după fiecare ciclu. Un astfel de ciclu poate să se execute o dată, de mai multe ori sau niciodată, în funcţie de valoarea la care se evaluează expresia. |
| - | char x = -1; | + | |
| - | int y = x; | + | |
| - | printf("%d\n", x); | + | == do ... while == |
| - | printf("%d\n", y); | + | |
| - | char a = 1; | + | ''do ... while'' este o instrucţiune repetitivă similara cu cea precedentă, singura diferenţa fiind că expresia este evaluată după executarea instrucţiunilor, nu înainte. Astfel, blocul va fi executat cel puţin o dată. |
| - | int b = a; | + | |
| - | printf("%d\n", a); | + | <code c> |
| - | printf("%d\n", b); | + | do { |
| - | + | // instructions | |
| - | return 0; | + | } while (expression); |
| - | } | + | |
| </code> | </code> | ||
| - | * <code c ex1g1.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | == for == |
| - | float f = 1 / 3; | + | |
| - | printf("%f\n", f); | + | ''for'' reprezintă o formă mai simplă de a scrie un while însotit de o expresie iniţiala şi de o expresie de incrementare. Forma sa este: |
| - | return 0; | + | <code c> |
| + | for (expression1; expression2; expression3) { | ||
| + | // instructions | ||
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1g2.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | Secvenţa de cod de mai sus este echivalentă cu: |
| - | float f = 1.0 / 3; | + | |
| - | printf("%f\n", f); | + | <code c> |
| - | + | expression1 | |
| - | return 0; | + | while (expression2) { |
| + | // instructions | ||
| + | expression3 | ||
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1h1.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | În cazul instrucţiunii ''for'', oricare dintre cele 3 expresii poate lipsi. Lipsa expresiei condiţionale este echivalentă cu o buclă infinită, cum ar fi: |
| - | float f = 0.7; | + | |
| - | if (f < 0.7) | + | <code c> |
| - | printf("0.7 < 0.7\n"); | + | for ( ; ; ) { |
| - | else if (f == 0.7) | + | /* instrucţiunile de aici sunt intr-o buclă infinită */ |
| - | printf("0.7 == 0.7\n"); | + | |
| - | else | + | |
| - | printf("0.7 > 0.7\n"); | + | |
| - | + | ||
| - | return 0; | + | |
| } | } | ||
| </code> | </code> | ||
| - | * <code c ex1h2.c> | ||
| - | #include <stdio.h> | ||
| - | int main(void) { | + | <note important> |
| - | double f = 0.7; | + | În acest caz, ieşirea din buclă trebuie făcută explicit, cu ajutorul instrucţiunii ''break''. |
| + | </note> | ||
| - | if (f < 0.7) | + | Exemplul următor prezintă un ciclu cu funcţionalitate identică (tipărirea primelor 10 numere naturale), folosind cele 3 instrucţiuni repetitive: |
| - | printf("0.7 < 0.7\n"); | + | |
| - | else if (f == 0.7) | + | |
| - | printf("0.7 == 0.7\n"); | + | |
| - | else | + | |
| - | printf("0.7 > 0.7\n"); | + | |
| - | return 0; | + | <code c> |
| + | int main() { | ||
| + | short i; | ||
| + | printf("Ciclu for\n"); | ||
| + | |||
| + | for (i = 1; i <= 10; i++) { | ||
| + | printf("i=%d\n", i); | ||
| + | } | ||
| + | |||
| + | printf("Ciclu while\n"); | ||
| + | i = 1; | ||
| + | while (i <= 10) { | ||
| + | printf("i=%d\n", i); | ||
| + | i++; | ||
| + | } | ||
| + | |||
| + | printf("Ciclu do while\n"); | ||
| + | i = 0; | ||
| + | do { | ||
| + | i++; | ||
| + | printf("i=%d\n", i); | ||
| + | } while(i < 10); | ||
| } | } | ||
| </code> | </code> | ||
| + | Pentru blocuri de o singură instrucţiune (cum este si cazul instructiunii executate de for in exemplul de mai sus) nu este nevoie sa folosim acolade. Totusi, folosirea acoladelor, chiar si in aceasta situatie, este recomandata pentru o depanare mai usoara si o lizibilitate mai buna a programelor. | ||
| - | **Următoarele două probleme vă vor fi date de asistent în cadrul laboratorului.** | + | === Instrucţiuni speciale === |
| - | [[https://drive.google.com/drive/folders/1qB6EZLGVubKbuTXMtMue06egH_8fo25M|Tasks]] | + | == break == |
| - | <hidden> | + | |
| - | Link direct către lista completă de probleme: [[https://docs.google.com/document/d/1FuBH9aYVzwSUs8Jd_TdxhHX10hyLrqfZ4X3ImXTYxvk/edit|aici]] | + | |
| - | Faceti vizibile doar link-urile spre problemele alese. | + | ''break'', pe lângă utilizarea descrisă la instrucţiunea switch, poate fi folosită pentru a ieşi forţat dintr-o instrucţiune de repetiţie. Secventa următoare este echivalentă cu cele de mai sus: |
| - | * {{:programare:laboratoare:checker.sh|Checker}} | + | |
| - | * {{:programare:laboratoare:ex1_1.zip|Ex1_1}} | + | |
| - | * {{:programare:laboratoare:ex1_2.zip|Ex1_2}} | + | |
| - | * Ex1_3 -- nu exista teste, trebuie verificat codul | + | |
| - | * Ex1_4 -- nu exista teste, trebuie verificat codul | + | |
| - | * {{:programare:laboratoare:ex2_1.zip|Ex2_1}} | + | |
| - | * {{:programare:laboratoare:ex2_2.zip|Ex2_2}} | + | |
| - | * {{:programare:laboratoare:ex2_3.zip|Ex2_3}} | + | |
| - | * {{:programare:laboratoare:ex2_4.zip|Ex2_4}} | + | |
| - | </hidden> | + | |
| - | ==== Probleme ==== | + | <code c> |
| + | i = 0; | ||
| + | for( ; ; ) { | ||
| + | i++; | ||
| + | if (i > 10) { | ||
| + | break; /* ieşire forţată din bucla */ | ||
| + | } | ||
| + | printf( "i=%d\n", i ); | ||
| + | } | ||
| + | </code> | ||
| - | - [1p] Studentul va rula împreună cu asistentul exemplele din laborator și va cere lămuriri acolo unde este cazul. | + | === continue === |
| - | - [0.5p + 0.5p] Să se verifice dacă un număr citit de la tastatură este număr par (prin două moduri). | + | |
| - | - [2p] Scrieți un program care numără descrescător de la 3->1, și după afișați ''START'' (cu interval de 1 secundă între fiecare număr). Exemplu: <code> | + | ''continue'' forţează terminarea iteraţiei curente a buclei si trecerea la iteraţia următoare. În cazul instrucţiunii ''for'', acest lucru presupune executarea instrucţiunii de incrementare; apoi se evaluează condiţia de continuare a buclei. Exemplul următor demonstrează implementarea unei bucle infinite cu ajutorul instrucţiunii ''continue'': |
| - | 3 //așteaptă o secundă | + | |
| - | 2 //așteaptă o secundă | + | <code c> |
| - | 1 //așteaptă o secundă | + | for (i = 0; i < 10; ) { |
| - | START | + | if (i == 0) { |
| + | continue; | ||
| + | } | ||
| + | i++; | ||
| + | } | ||
| </code> | </code> | ||
| - | - [3p] Fiind date 3 numere naturale, citite de la tastatură, să se verifice dacă ele reprezintă laturile unui triunghi, în cazul în care acestea pot forma un triunghi se va afișa mesajul "DA", în caz contrar "NU". | ||
| - | - [3p] Scrieți un program care calculează 5 valori aleatoare și le afișează pe ecran, folosind ca seed ceasul sistemului, ca mai sus. Executați de mai multe ori programul. Inlocuiți apoi seed-ul cu o valoare constantă (''0x1234'' de exemplu) si rulați din nou programul de câteva ori la rând. Ce observaţi? Care e explicaţia? | ||
| - | === Bonus: === | + | === return === |
| - | Va fi dat de către asistent. | + | |
| - | <hidden> | + | ''return'' este instrucţiunea de terminare a funcţiei curente. Aceasta poate fi apelată in forma ''return''; în cazul funcţiilor care returnează ''void'' şi în forma ''return //result//''; pentru funcţiile care întorc o valoare. |
| - | - Să se citească de la tastatură 3 numere reale (a,b,c), care reprezintă parametrii unei ecuații de gradul 2 (''//ax//''<sup>''//2//''</sup>''// + bx + c //''= 0), să se verifice câte rădăcini reale are şi valoarea acestora. Se vor folosi mesajele: ''Ecuația nu are rădăcini reale, Ecuația are o singură rădăcină reală egală cu ...'', respectiv ''Ecuația are două rădăcini reale ... şi ....'' | + | === goto === |
| - | - Să se verifice folosind operații pe biți că un număr M citit de la tastatură este putere a lui 2. Calculați 2 la puterea N. | + | ''goto'' este o instrucţiune de salt a execuţiei. Instrucţiunea primeşte ca parametru o etichetă; următoarea instrucţiune executată după ''goto'' este cea de la eticheta dată. |
| - | - Se dau N puncte in plan (date prin coordonatele x şi y), citite de la tastatură, care reprezintă vârfurile unui poligon convex. Punctele sunt date în ordine trigonometrică (sau invers trigonometrică) să se calculeze: | + | <code c> |
| - | * perimetrul poligonului convex | + | int main() { |
| - | * aria poligonului convex | + | goto et; |
| - | </hidden> | + | printf("Asta nu apare la executie\n"); |
| + | |||
| + | et: | ||
| + | printf("Asta apare la rulare\n"); | ||
| + | return 0; | ||
| + | } | ||
| + | </code> | ||
| - | ==== Extra ==== | + | <note important> |
| - | * [[https://github.com/cs-pub-ro/ComputerProgramming/blob/master/Laboratories/Lab2/cheatsheet.pdf|Cheatsheet]] | + | În majoritatea cazurilor, utilizarea instrucţiunii ''goto'' nu este recomandată şi poate fi evitată folosind alte instrucţiuni de control şi funcţii. Programele care folosesc această instrucţiune pentru a sări între secvenţe îndepărtate de cod sunt dificil de depanat şi analizat. |
| + | </note> | ||
| - | </hidden> | + | ==== Exerciții ==== |
| + | Exercițiile pentru laborator se găsesc pe [[https://acs-pclp.github.io/laboratoare/02 | PCLP Laborator02 - Tipuri de date. Operatori. Instrucțiunile limbajului C]]. | ||
| ==== Referinţe ==== | ==== Referinţe ==== | ||
| Line 461: | Line 504: | ||
| * [[http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B|Wikipedia - Operators in C and C++]] | * [[http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B|Wikipedia - Operators in C and C++]] | ||
| * [[http://en.wikipedia.org/wiki/C_mathematical_functions|Wikipedia - C mathematical functions]] | * [[http://en.wikipedia.org/wiki/C_mathematical_functions|Wikipedia - C mathematical functions]] | ||
| + | * [[http://www.tutorialspoint.com/ansi_c/c_control_statements.htm|C - Control Statements]] | ||
| + | |||
