BitCell

Probabil ca trebuie o mica recapitulare (pentru mine cel putin)

Grafice de functii

I. Domeniul de definitie
a) se precizeaza domeniul de definitie rezultat in urma punerii conditiilor de existenta a functiei (exemplu: daca f(x)=1/(2*x-1); atunci x nu poate fi 1/2).
b) se studiaza daca functia este para, impara sau periodica.
c) se determina intersectiile graficului functiei (Gf) cu axele de coordonate:
Gf intersectat cu Ox; afica y=f(x)=0, se calculeaza x;
GF intersectat cu Oy; adica x=0, se afla y=f(0);
d) limitele la capetele intervalelor disjuncte ce apar in domeniul de definitie.
e) calculul asimptotelor:
m = limita(cind x tinde la plus sau minus infinit) de f(x)/x
n = limita(cind x tinde la plus sau minus infinit) de f(x)-mx
rezulta asimptotele y=mx+n;

II. Derivata de ordinul I
a) se calculeaza f'(x) si se precizeaza semnul pe domeniul de definitie determinat anterior
b) se rezolva ecuatia f'(x)=0;
c) se face un tabel de semn pentru f'(x), se precizeaza punctele de extrem si monotonia

III. Derivata de ordinul II
a) se calculeaza f''(x)
b) se rezolva ecuatia f''(x)=0
c) se face un tabel de semn pentru f''(x), se precizeaza punctele de inflexiune, concavitatea, convexitatea


In Java, ca sa desenezi o linie: http://www.java2s.com/Code/Java/2D-Grap ... awline.htm

Va multumesc pentru sfaturi!

Recomand o carte de matematica: "Tabele si formule matematice" de E. Rogai, de la "EDITURA TEHNICA".
Pe vremea cind eram in scoala, orice prof respectabil avea asa ceva in biblioteca.

La pagina 394-395 gasesti instructiuni mai detaliate pentru reprezentarea grafica a functiilor (capitol 5.8.5)
La pagina 383 gasesti derivatele functiilor elementare.
M-a pus proful din liceu sa imi fac un carnetel cu formule , am acolo un rezumat cu derivatele functiilor elementare.
Operatii cu functii derivabile:
1. (g+h)' = g' + h'; ( lucram cu f(x) = g(x) + h(x) )
2. (a*g)' = a * g'; a este constanta
3. (g*h)' = g' * h + g * h'
4. (g/h)' = (g' * h - h * g') / (h*h)
etc...
probabil le stii, si asta e inceputul pentru un algoritm de derivare simbolica.

Si acum referitor la o fereastra in java (asta e valabil si pentru gwbasic):
in stinga sus ai coordonatele win_x=0, win_y=0;
latimea si lungimea ferestei trebuie sa fie mai mici sau egale cu ale ecranului; sa le numim win_max_x, win_max_y;
sa definim centrul: center_x = (win_max_x - win_x) / 2; center_y = (win_max_y - win_y) /2;
Sa definim functia punct_x_y(x,y) { deseneaza_punct_la(center_x - x, center_y + y) }; deoarece asa sunt coordonatele ecranului si trebuie sa le corectam.
Probabil va trebui sa continui cu functia linie, tot asa, relativ, dar cred ca se intelege ideea.

p.s. un prieten matematician, a reusit sa reprezinte grafic ceva de teoria haosului, in gwbasic, dupa ce i-am explicat cum e cu aceste coordonate de ecran.
Daca sunt necesare lamuriri suplimentare, spuneti.

Eu pot sa ajut doar cu o implementare în C/C++. Codul e scris puţin în grabă, dar sper că îl va traduce cineva în Java.

Folosind polimorfismul, am plecat de la ideea de expresie. Am considerat că atât operaţiile aritmetice cât şi funcţiile sunt expresii, pe care le-am clasificat în expresii unare, expresii binare, valori constante, variabile şi funcţii (cu un argument sau cu mai multe argumente).

Fiecare expresie poate fi formatată, evaluata (in functie de x), derivata, dar majoritatea acestor operaţii trebuie implementate în clasele "moştenitoare".

Clasele String şi Array nu există; le-am folosit doar în mod simbolic; înlocuiţi-le cu un echivalent.
La evaluarea expresiilor am folosit tipul double; dacă este nevoie, înlocuiţi-l cu alt tip.




Următoarele clase sunt polimorfice şi din ele trebuie derivate noile clase:

Expression
   |---UnaryExpression
   |---BinaryExpression
   |---Function
   |------UnaryFunction

clasa Expression -- furnizează 4 funcţii polimorfice:
-- int getPriority() -- folosită la formatarea expresiilor; se supraîncarcă pentru a indica propritatea operatorilor
-- String formatExpression([int priority]) -- implementată în clasele descendente, formatează conţinutul expresiilor
-- double evaluate(double) -- implementată în clasele descendente, evaluează expresia în funcţie de variabila x
-- Expression* derrive() -- implementată în clasele descendente, returnează o expresie nouă, prin derivarea expresiei curente

clasa UnaryExpression -- conţine ca variabilă membră, o expresie, pe post de operand unic.

clasa BinaryExpression -- în mod asemănător cu UnaryExpression, conţine 2 expresii, pe post de operanzi. Operaţiile aritmetice de bază pornesc de la această clasă şi implementează funcţiile de formatare, evaluare şi derivare.

clasa Function -- clasa de bază pentru funcţii predefinite. Clasa memorează o listă de argumente şi implementează funcţia de formatare, folosind notaţia tipică a funcţiilor.
Adaugă o nouă funcţie polimorfică: String getFunctionName(), a cărei rol este de a furniza un nume pentru funcţia de formatare.
Rămân 2 funcţii virtuale neimplementate:
-- double evaluate(double)
-- Expression* derrive()

UnaryFunction -- nu aduce nimic nou; doar simplifică uşor scrierea funcţiilor cu un singur argument


Următoarele clase sunt finalizate:

Value (implementează UnaryExpression) -- memorează valori de tip double. Funcţiile de evaluare,formatare şi derivare sunt deja implementate. Ori de câte ori avem nevoie să memorăm o valoare într-o expresie, folosim constructorul: new Value(<valoare>).

Variable (implementează UnaryExpression) -- memorează parametrul x al funcţiei pe care vrem să o evaluăm. Funcţiile de evaluare,formatare şi derivare sunt deja implementate. Când avem nevoie să introducem variabila x într-o expresie, folosim constructorul: new Variable()

---

Câteva exemple de implementare pentru clasele de mai sus:

Negation (implementează UnaryExpression) -- este negarea algebrică a unei expresii (de forma -x). Clasa memorează expresia ce trebuie negată, iar funcţiile de formatare, evaluare, derivare sunt implementate în funcţie de expresia respectivă.


 
Addition, Subtraction, Product (implementează BinaryExpression) -- cei 2 operanzi sunt memoraţi, iar operaţiile de evaluare, formatare şi derivare se fac în funcţie de aceştia.


 
Sinus, Cosinus (implementează UnaryFunction) -- singurul argument este memorat (aproape) automat în clasa UnaryFunction. Datorită faptului că funcţia de formatare este implementată deja în clasa Function, este suficient ca noi să definim funcţia "getFunctionName".

Funcţia de evaluare apelează funcţia de evaluare a argumentului (argument[0]->evaluate). Rezultatul este folosit ca argument pentru funcţia curentă.

Funcţiile de derivare de mai jos sunt un exemplu de utilizare pentru clasele pe care le-am definit.
 


Mai trebuie implementate câteva funcţii şi câteva operaţii matematice, iar de aici calculatorul se descurcă singur.

Sper că ajută. Codul nu e scris să funcţioneze direct; are mai mult rolul de a explica ideea de implementare.