Untitled

1. Rezistența echivalentă serie și paralel pentru 3 rezistoare;

RezistentaCalculator.h

#ifndef RESISTENTACALCULATOR_H
#define RESISTENTACALCULATOR_H

class RezistentaCalculator {
private:
    double R1, R2, R3;
public:
    RezistentaCalculator(double r1 = 0, double r2 = 0, double r3 = 0) : R1(r1), R2(r2), R3(r3) {}
    void SetRezistente(double r1, double r2, double r3) {R1 = r1;R2 = r2;R3 = r3;}
    double CalculeazaSerie() const {return R1 + R2 + R3;}
    double CalculeazaParalel() const {return 1.0 / (1.0 / R1 + 1.0 / R2 + 1.0 / R3);}
};
#endif

main.cpp

double R1, R2, R3;
TextCtrl1->GetValue().ToDouble(&R1);
TextCtrl2->GetValue().ToDouble(&R2);
TextCtrl3->GetValue().ToDouble(&R3);
RezistentaCalculator calc(R1, R2, R3);
double rezSerie = calc.CalculeazaSerie();
double rezParalel = calc.CalculeazaParalel();
TextCtrl4->SetValue(wxString::Format("%.2f", rezSerie));
TextCtrl5->SetValue(wxString::Format("%.2f", rezParalel));

2. Capacitatea echivalentă serie și paralel pentru 3 condensatoare;

CapacitateCalculator.h

#ifndef CAPACITATE_CALCULATOR_H
#define CAPACITATE_CALCULATOR_H

class CapacitateCalculator {
private:
    double C1, C2, C3;
public:
    CapacitateCalculator(double c1 = 0, double c2 = 0, double c3 = 0) : C1(c1), C2(c2), C3(c3) {}
void SetCapacitati(double c1, double c2, double c3) {C1 = c1;C2 = c2;C3 = c3;}
double CalculeazaParalel() const {return C1 + C2 + C3;}
double CalculeazaSerie() const {return 1.0 / (1.0 / C1 + 1.0 / C2 + 1.0 / C3);}
};
#endif

main.cpp

double C1, C2, C3;
TextCtrl1->GetValue().ToDouble(&C1);
TextCtrl2->GetValue().ToDouble(&C2);
TextCtrl3->GetValue().ToDouble(&C3);
CapacitateCalculator calc(C1, C2, C3);
double capacitateParalel = calc.CalculeazaParalel();
double capacitateSerie = calc.CalculeazaSerie();
TextCtrl4->SetValue(wxString::Format("%.2f", capacitateParalel));
TextCtrl5->SetValue(wxString::Format("%.2f", capacitateSerie));

3. Triunghiul puterilor, când se cunoaște factorul de putere și puterea aparentă;

TriunghiPuterilor.h

#ifndef TRIUNGHI_PUTERILOR_H
#define TRIUNGHI_PUTERILOR_H

#include <cmath>

class TriunghiPuterilor {
private:
    double factorPutere;
    double putereAparenta;
public:
    TriunghiPuterilor(double pA = 0, double fP = 0) : putereAparenta(pA), factorPutere(fP) {}
void SetDate(double pA, double fP) {putereAparenta = pA;factorPutere = fP;}
double CalculeazaPutereActiva() const {
return putereAparenta * factorPutere;}
double CalculeazaPutereReactiva() const {
return putereAparenta * std::sqrt(1 - std::pow(factorPutere, 2));}
};
#endif

main.cpp

double putereAparenta, factorPutere;
TextCtrl1->GetValue().ToDouble(&putereAparenta);
TextCtrl2->GetValue().ToDouble(&factorPutere);
TriunghiPuterilor calc(putereAparenta, factorPutere);
double putereActiva = calc.CalculeazaPutereActiva();
double putereReactiva = calc.CalculeazaPutereReactiva();
TextCtrl3->SetValue(wxString::Format("%.2f", putereActiva));
TextCtrl4->SetValue(wxString::Format("%.2f", putereReactiva));

4. Rezolvarea ecuației de gradul I, pentru două ecuații în același timp;

EcuatieGrad1.h

#ifndef ECUATIE_GRAD1_H
#define ECUATIE_GRAD1_H

class EcuatieGrad1 {
private:
    double a, b;
public:
EcuatieGrad1(double coefA = 0, double coefB = 0) : a(coefA), b(coefB) {}
void SetCoeficienti(double coefA, double coefB) {a = coefA;b = coefB;}
double Rezolva() const {
if (a == 0) throw "Ecuatia nu are solutie.";
return -b / a;}
};
#endif

main.cpp

double a1, b1, a2, b2;
TextCtrl1->GetValue().ToDouble(&a1);
TextCtrl2->GetValue().ToDouble(&b1);
TextCtrl3->GetValue().ToDouble(&a2);
TextCtrl4->GetValue().ToDouble(&b2);
EcuatieGrad1 ecuatie1(a1, b1);
EcuatieGrad1 ecuatie2(a2, b2);
double sol1 = ecuatie1.Rezolva();
double sol2 = ecuatie2.Rezolva();
TextCtrl5->SetValue(wxString::Format("%.2f", sol1));
TextCtrl6->SetValue(wxString::Format("%.2f", sol2));

5. Rezolvarea ecuației de gradul II;

EcuatieGrad2.h

#ifndef ECUATIE_GRAD2_H
#define ECUATIE_GRAD2_H
#include <cmath>
#include <stdexcept>

class EcuatieGrad2 {
private:
    double a, b, c;
public:
    EcuatieGrad2(double coefA = 0, double coefB = 0, double coefC = 0) : a(coefA), b(coefB), c(coefC) {}
    void SetCoeficienti(double coefA, double coefB, double coefC) {a = coefA;b = coefB;c = coefC;}
    double Delta() const {return b * b - 4 * a * c;}
    void Rezolva(double& x1, double& x2) const {
        double delta = Delta();
        if (delta < 0) throw std::runtime_error("Delta negativ. Solutii complexe.");
        x1 = (-b + std::sqrt(delta)) / (2 * a);
        x2 = (-b - std::sqrt(delta)) / (2 * a);}
};
#endif

main.cpp

    double a, b, c;
    TextCtrl1->GetValue().ToDouble(&a);
    TextCtrl2->GetValue().ToDouble(&b);
    TextCtrl3->GetValue().ToDouble(&c);
    EcuatieGrad2 ecuatie(a, b, c);
    try {
        double x1, x2;
        ecuatie.Rezolva(x1, x2);
        TextCtrl4->SetValue(wxString::Format("%.2f", x1));
        TextCtrl5->SetValue(wxString::Format("%.2f", x2));
    } catch (const std::exception& e) {
    wxMessageBox(e.what(), "Eroare", wxICON_ERROR);}
	
6. Consumul de combustbil la un automobil și prețul acestuia;

ConsumulCombustibil.h

#ifndef CONSUMUL_COMBUSTIBIL_H
#define CONSUMUL_COMBUSTIBIL_H

class ConsumulCombustibil {
private:
    double distanta;
    double consumMediu;
    double pretCombustibil;
public:
    ConsumulCombustibil(double d = 0, double c = 0, double p = 0) : distanta(d), consumMediu(c), pretCombustibil(p) {}
    void SetDate(double d, double c, double p) {distanta = d;consumMediu = c;pretCombustibil = p;}
    double CalculeazaConsumTotal() const {return (distanta / 100.0) * consumMediu;}
    double CalculeazaCostTotal() const {return CalculeazaConsumTotal() * pretCombustibil;}
};
#endif

main.cpp

double distanta, consumMediu, pretCombustibil;
TextCtrl1->GetValue().ToDouble(&distanta);
TextCtrl2->GetValue().ToDouble(&consumMediu);
TextCtrl3->GetValue().ToDouble(&pretCombustibil);
ConsumulCombustibil calc(distanta, consumMediu, pretCombustibil);
double consumTotal = calc.CalculeazaConsumTotal();
double costTotal = calc.CalculeazaCostTotal();
TextCtrl4->SetValue(wxString::Format("%.2f", consumTotal));
TextCtrl5->SetValue(wxString::Format("%.2f", costTotal));

7. Aria și volumul unei sfere;

Sfera.h

#ifndef SFERA_H
#define SFERA_H

#include <cmath>

class Sfera {
private:
    double raza;
public:
    Sfera(double r = 0) : raza(r) {}
    void SetRaza(double r) {raza = r;}
    double CalculeazaArie() const {return 4 * M_PI * raza * raza;}
    double CalculeazaVolum() const {return (4.0 / 3.0) * M_PI * std::pow(raza, 3);}
};
#endif

main.cpp

double raza;
TextCtrl1->GetValue().ToDouble(&raza);
Sfera calc(raza);
double arie = calc.CalculeazaArie();
double volum = calc.CalculeazaVolum();
TextCtrl2->SetValue(wxString::Format("%.2f", arie));
TextCtrl3->SetValue(wxString::Format("%.2f", volum));

8. Aria și volumul unei piramide;

Piramida.h

#ifndef PIRAMIDA_H
#define PIRAMIDA_H

#include <cmath>

class Piramida {
private:
    double baza, inaltime, inaltimeLaterala;
public:
    Piramida(double b = 0, double h = 0, double hLat = 0) : baza(b), inaltime(h), inaltimeLaterala(hLat) {}
    void SetDimensiuni(double b, double h, double hLat) {baza = b;inaltime = h;inaltimeLaterala = hLat;}
    double CalculeazaArie() const {return baza * baza + 4 * (baza * inaltimeLaterala / 2);}
    double CalculeazaVolum() const {return (baza * baza * inaltime) / 3;}
};
#endif

main.cpp

double baza, inaltime, inaltimeLaterala;
TextCtrl1->GetValue().ToDouble(&baza);
TextCtrl2->GetValue().ToDouble(&inaltime);
TextCtrl3->GetValue().ToDouble(&inaltimeLaterala);
Piramida calc(baza, inaltime, inaltimeLaterala);
double arie = calc.CalculeazaArie();
double volum = calc.CalculeazaVolum();
TextCtrl4->SetValue(wxString::Format("%.2f", arie));
TextCtrl5->SetValue(wxString::Format("%.2f", volum));

9. Aria și volumul unui cilindru;

Cilindru.h

#ifndef CILINDRU_H
#define CILINDRU_H

#include <cmath>

class Cilindru {
private:
    double raza, inaltime;
public:
    Cilindru(double r = 0, double h = 0) : raza(r), inaltime(h) {}
    void SetDimensiuni(double r, double h) {raza = r;inaltime = h;}
    double CalculeazaArie() const {return 2 * M_PI * raza * (raza + inaltime);}
    double CalculeazaVolum() const {return M_PI * raza * raza * inaltime;}
};
#endif

main.cpp

double raza, inaltime;
TextCtrl1->GetValue().ToDouble(&raza);
TextCtrl2->GetValue().ToDouble(&inaltime);
Cilindru calc(raza, inaltime);
double arie = calc.CalculeazaArie();
double volum = calc.CalculeazaVolum();
TextCtrl3->SetValue(wxString::Format("%.2f", arie));
TextCtrl4->SetValue(wxString::Format("%.2f", volum));

10. Energia cinetcă și potențială;

Energie.h

#ifndef ENERGIE_H
#define ENERGIE_H

class Energie {
private:
    double masa; double viteza; double inaltime; const double g = 9.81;
public:
    Energie(double m = 0, double v = 0, double h = 0) : masa(m), viteza(v), inaltime(h) {}
void SetDate(double m, double v, double h) {masa = m;viteza = v;inaltime = h;}
double CalculeazaEnergieCinetica() const {return 0.5 * masa * viteza * viteza;}
double CalculeazaEnergiePotentiala() const {return masa * g * inaltime;}
};
#endif

main.cpp

double masa, viteza, inaltime;
TextCtrl1->GetValue().ToDouble(&masa);
TextCtrl2->GetValue().ToDouble(&viteza);
TextCtrl3->GetValue().ToDouble(&inaltime);
Energie calc(masa, viteza, inaltime);
double energieCinetica = calc.CalculeazaEnergieCinetica();
double energiePotentiala = calc.CalculeazaEnergiePotentiala();
TextCtrl4->SetValue(wxString::Format("%.2f", energieCinetica));
TextCtrl5->SetValue(wxString::Format("%.2f", energiePotentiala));

11. Media aritmetcă și geometrică a 5 numere;

Medie.h

#ifndef MEDIE_H
#define MEDIE_H

#include <cmath>

class Medie {
private:
    double n1, n2, n3, n4, n5;
public:
Medie(double num1, double num2, double num3, double num4, double num5) : n1(num1), n2(num2), n3(num3), n4(num4), n5(num5) {}
double CalculeazaMedieAritmetica() const {return (n1 + n2 + n3 + n4 + n5) / 5.0;}
double CalculeazaMedieGeometrica() const {double produs = n1 * n2 * n3 * n4 * n5;return exp(log(produs) / 5);}
};
#endif

main.cpp

double n1, n2, n3, n4, n5;
TextCtrl1->GetValue().ToDouble(&n1);
TextCtrl2->GetValue().ToDouble(&n2);
TextCtrl3->GetValue().ToDouble(&n3);
TextCtrl4->GetValue().ToDouble(&n4);
TextCtrl5->GetValue().ToDouble(&n5);
Medie calc(n1, n2, n3, n4, n5);
double medieAritmetica = calc.CalculeazaMedieAritmetica();
double medieGeometrica = calc.CalculeazaMedieGeometrica();
TextCtrl6->SetValue(wxString::Format("%.2f", medieAritmetica));
TextCtrl7->SetValue(wxString::Format("%.2f", medieGeometrica));

12. Media ponderată a 5 numere;

MediePonderata.h

#ifndef MEDIE_PONDERATA_H
#define MEDIE_PONDERATA_H

class MediePonderata {
private:
double n1, n2, n3, n4, n5;
double p1, p2, p3, p4, p5;
public:
MediePonderata(double num1, double num2, double num3, double num4, double num5, double pon1, double pon2, double pon3, double pon4, double pon5)
: n1(num1), n2(num2), n3(num3), n4(num4), n5(num5), p1(pon1), p2(pon2), p3(pon3), p4(pon4), p5(pon5) {}
double CalculeazaMediePonderata() const {
double sumaNumerePonderate = n1 * p1 + n2 * p2 + n3 * p3 + n4 * p4 + n5 * p5;
double sumaPonderi = p1 + p2 + p3 + p4 + p5;
return sumaNumerePonderate / sumaPonderi;}
};
#endif

main.cpp

double n1, n2, n3, n4, n5;
double p1, p2, p3, p4, p5;
TextCtrl1->GetValue().ToDouble(&n1);
TextCtrl2->GetValue().ToDouble(&n2);
TextCtrl3->GetValue().ToDouble(&n3);
TextCtrl4->GetValue().ToDouble(&n4);
TextCtrl5->GetValue().ToDouble(&n5);
TextCtrl6->GetValue().ToDouble(&p1);
TextCtrl7->GetValue().ToDouble(&p2);
TextCtrl8->GetValue().ToDouble(&p3);
TextCtrl9->GetValue().ToDouble(&p4);
TextCtrl10->GetValue().ToDouble(&p5);
MediePonderata calc(n1, n2, n3, n4, n5, p1, p2, p3, p4, p5);
double mediePonderata = calc.CalculeazaMediePonderata();
TextCtrl11->SetValue(wxString::Format("%.2f", mediePonderata));

13. Dobânda unui depozit la termen;

Dobanda.h

#ifndef DOBANDA_H
#define DOBANDA_H

class Dobanda {
private:
double suma; double rata; int durata;
public:
Dobanda(double s = 0, double r = 0, int d = 0) : suma(s), rata(r), durata(d) {}
void SetDate(double s, double r, int d) {suma = s; rata = r; durata = d;}
double CalculeazaDobandaSimpla() const {return suma * rata / 100.0 * durata;}
double CalculeazaDobandaCompusa() const {return suma * std::pow(1 + rata / 100.0, durata) - suma;}
};
#endif

main.cpp

double suma, rata;
int durata;
TextCtrl1->GetValue().ToDouble(&suma);
TextCtrl2->GetValue().ToDouble(&rata);
TextCtrl3->GetValue().ToLong((long*)&durata);
Dobanda calc(suma, rata, durata);
double dobandaSimpla = calc.CalculeazaDobandaSimpla();
double dobandaCompusa = calc.CalculeazaDobandaCompusa();
TextCtrl4->SetValue(wxString::Format("%.2f", dobandaSimpla));
TextCtrl5->SetValue(wxString::Format("%.2f", dobandaCompusa));

14. Conversia valutară pentru 5 monede;

ConversieValutara.h

#ifndef CONVERSIE_VALUTARA_H
#define CONVERSIE_VALUTARA_H

class ConversieValutara {
private:
double suma; double rata1; double rata2; double rata3; double rata4; double rata5;
public:
ConversieValutara(double s = 0, double r1 = 0, double r2 = 0, double r3 = 0, double r4 = 0, double r5 = 0)
: suma(s), rata1(r1), rata2(r2), rata3(r3), rata4(r4), rata5(r5) {}
void SetDate(double s, double r1, double r2, double r3, double r4, double r5) {
suma = s; rata1 = r1; rata2 = r2; rata3 = r3; rata4 = r4; rata5 = r5;}
double CalculeazaEchivalent1() const {return suma * rata1;}
double CalculeazaEchivalent2() const {return suma * rata2;}
double CalculeazaEchivalent3() const {return suma * rata3;}
double CalculeazaEchivalent4() const {return suma * rata4;}
double CalculeazaEchivalent5() const {return suma * rata5;}
};
#endif

main.cpp

double suma, rata1, rata2, rata3, rata4, rata5;
TextCtrl1->GetValue().ToDouble(&suma);
TextCtrl2->GetValue().ToDouble(&rata1);
TextCtrl3->GetValue().ToDouble(&rata2);
TextCtrl4->GetValue().ToDouble(&rata3);
TextCtrl5->GetValue().ToDouble(&rata4);
TextCtrl6->GetValue().ToDouble(&rata5);
ConversieValutara calc(suma, rata1, rata2, rata3, rata4, rata5);
double echivalent1 = calc.CalculeazaEchivalent1();
double echivalent2 = calc.CalculeazaEchivalent2();
double echivalent3 = calc.CalculeazaEchivalent3();
double echivalent4 = calc.CalculeazaEchivalent4();
double echivalent5 = calc.CalculeazaEchivalent5();
TextCtrl7->SetValue(wxString::Format("%.2f", echivalent1));
TextCtrl8->SetValue(wxString::Format("%.2f", echivalent2));
TextCtrl9->SetValue(wxString::Format("%.2f", echivalent3));
TextCtrl10->SetValue(wxString::Format("%.2f", echivalent4));
TextCtrl11->SetValue(wxString::Format("%.2f", echivalent5));

15. Salariul net din brut, când se precizează procentul pentru impozit, sănătate și pensie;

SalariuNet.h

#ifndef SALARIU_NET_H
#define SALARIU_NET_H

class SalariuNet {
private:
double salariuBrut; double impozit; double sanatate; double pensie;
public:
SalariuNet(double brut = 0, double imp = 0, double san = 0, double pen = 0)
: salariuBrut(brut), impozit(imp), sanatate(san), pensie(pen) {}
void SetDate(double brut, double imp, double san, double pen) {
salariuBrut = brut; impozit = imp; sanatate = san; pensie = pen;}
double CalculeazaSalariuNet() const {
double deduceri = salariuBrut * (impozit + sanatate + pensie) / 100.0;
return salariuBrut - deduceri;}
};
#endif

main.cpp

double salariuBrut, impozit, sanatate, pensie;
TextCtrl1->GetValue().ToDouble(&salariuBrut);
TextCtrl2->GetValue().ToDouble(&impozit);
TextCtrl3->GetValue().ToDouble(&sanatate);
TextCtrl4->GetValue().ToDouble(&pensie);
SalariuNet calc(salariuBrut, impozit, sanatate, pensie);
double salariuNet = calc.CalculeazaSalariuNet();
TextCtrl5->SetValue(wxString::Format("%.2f", salariuNet));