API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 24th, 2017
56
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 19.57 KB | None | 0 0
raw download clone embed print report
  1. // #include "Polynom.h"
  2. #include <stdarg.h> // für va_list a, va_start(a,anzahl), va_next(a, typ von ...), va_end(a)
  3.                     // in typ Funktion(int anzahl,...) => Variable Anzahl von Parametern
  4. #include <iostream> // Input per std::cin>>.. & Output per std::cout<<.., ..<<std::endl;
  5. using namespace std; // für cin>>.., cout<<.., ..<<endl; ohne std:: davor
  6.  
  7.  
  8. // Polynom.h
  9. /* Polynom
  10.  
  11.     f(x) = [Summe, i=0 bis n] a_i * x^i
  12.         = a_0 + a_1 * x + a_2 * x^2 + ... + a_(n-1) * x^(n-1) + a_n * x^n
  13.         = a_0 + x * (a_1 + x * (a_2 + x * (...(a_(n-1) + x * a_(n))...))) (Horner-Schema)
  14.  
  15.     Grad: Als Grad des Polynoms wird der höchste Exponent n bezeichnet,
  16.         für den der Koeffizient a_n des Monoms a_n * x^n  nicht null ist.
  17.         Dieser Koeffizient heißt Leitkoeffizient. => Grad = max{ n | a_n != 0}
  18.     f(x)=0 => Grad(f)=-(unendlich), Nullpolynom
  19.     f(x)=a_0, a_0 != 0 => Grad(f)=0, konstante Funktion
  20.     f(x)=a_0 + a_1 * x, a1!=0 => Grad(f)=1, lineare Funktionen
  21.     Grad(f)=2 => quadratische Funktion; Grad(f)=3 => kubische Funktion; Grad(f)=4 => quartische Funktion
  22.  
  23.     Ableitung f'(x) von [Summe, i=0 bis n] a_i * x^i = [Summe, i=1 bis n] i * a_i * x^(i-1)
  24.         = a_1 + 2 * a_2 * x + 3 * a_3 * x^2 + ... + (n-1) * a_(n-1) * x^(n-2) + n * a_n * x^(n-1)
  25.    
  26.     Integral: a<=b: aS^b f(x) dx = F(b) - F(a); a>b: aS^b f(x) dx = -(bS^a f(x) fx) = -(F(a) - F(b))
  27.    
  28.     Implementierung:
  29.     - Koeffizienten a_i in einem Array a speichern, s.d. a_i * x^i ^= a[i]
  30.     - dazu noch grad für grad; -8 ^= -(unendlich);
  31. */
  32.  
  33. class Polynom {
  34.     private:
  35.         int grad;
  36.         // int groesse; => if (grad != -8) -> groesse=grad+1; else [if grad==-8]-> groesse=1;
  37.         double* a;
  38.     public:
  39.         Polynom(); // Default-Konstruktor (Nullpolynom)
  40.         Polynom(int x, double b[]); // 1. Konstruktor
  41.         Polynom(int x,...); // 2. Konstruktor
  42.         Polynom(const Polynom& g); // Copy-Konstruktor
  43.         ~Polynom(); // Destruktor
  44.         int get_grad(); //-8 ^= -(unendlich);
  45.         void AusgabeG(); // a_0 * x^0 + a_1 *x^1 + ... + a_n * x^n, inkl. 0 * x^i
  46.         void AusgabeGU(); // a_n * x^n + ... + a_1 * x^1 + a_0 * x^0, inkl. 0 * x^i
  47.         void Ausgabe(); // a_0 + a_1 * x + ... + a_n * x^n, sofern a_i != 0
  48.         void AusgabeU(); // a_n * x^n + ... + a_1 * x + a_0, sofern a_i != 0
  49.         bool gleich(Polynom g); // if (f==g)?
  50.         bool ungleich(Polynom g); // if (f!=g)?
  51.         bool Achsensymmetrisch(); // Achsensymmetrisch zur y-Achse; a_0 * x^0 + a_2 * x^2 + ... + a_(2k) * x^(2k)
  52.         bool Punktsymmetrisch(); // Punktsymmtrisch zum Ursprung; a_1 * x^1 + a_3 * x^3 + ... + a_(2k+1) * x^(2k+1)
  53.         double AuswertungT(double u); // triviale/einfache/gewöhnliche Auswertung
  54.         double Auswertung(double u); // Auswertung nach Horner-Schema
  55.         Polynom Addition(Polynom g); // f+g (=g+f)
  56.         Polynom Minus(); // f -> -f
  57.         Polynom Substraktion(Polynom g); // f-g (=f+(-g))
  58.         Polynom SubstraktionAlt(Polynom g); // f+(-g) (=f-g)
  59.         // Polynom Multiplikation(Polynom g); // f*g (=g*f)
  60.         // Polynom Division(Polynom g); // f:g v f/g
  61.         // Polynom[] Faktorisierung();
  62.         // double [] Nullstellen();
  63.         // Polynombrüche, wie 1/x = x^1 usw.
  64.          // ggf. "Polynom operator # (const Polynom& g) const;" , um bei zB. h=f+g; f und g per const zu schützen?
  65.         bool operator == (const Polynom& g);
  66.         bool operator != (const Polynom& g);
  67.         Polynom operator = (const Polynom& g);
  68.         Polynom operator + (const Polynom& g);
  69.         Polynom operator - ();
  70.         Polynom operator - (const Polynom& g);
  71.         // Polynom operator * (const Polynom& g);
  72.         // Polynom operator / (const Polynom& g);
  73.         Polynom Ableitung(); // f -> f'
  74.         Polynom Stammfunktion(); // f -> F
  75.         double Integral(double untereGrenze, double obereGrenze);
  76. };
  77.  
  78.  
  79. // Polynom.cpp
  80. Polynom::Polynom() { // Default-Konstruktor (Nullpolynom)
  81.     grad=-8; a=new double[1]; a[0]=0.0;
  82. }
  83. Polynom::Polynom(int x, double b[]) { // Konstruktor 1. Eingabe: Anzahl der Elemente (int) und Array (double), b[j] ^= b[j] * x^j
  84.     for (int i=x-1; i>=0; i--) { // führende 0en 'entfernen'; (sizeof(b)/sizeof(b[0]))
  85.         grad = i;
  86.         if (b[i] != 0.0) {
  87.             i=-1;
  88.         }
  89.     }
  90.     if (grad == 0.0 && b[0] == 0.0) { // Nullpolynom
  91.         grad=-8; a=new double[1]; a[0]=0.0;
  92.     }
  93.     else {
  94.         a=new double[grad+1];
  95.         for (int i=0; i<=grad; i++) { // b ohne führende 0en in a speichern
  96.             a[i] = b[i];
  97.         }
  98.     }
  99. }
  100. Polynom::Polynom(int x,...) { // Konstruktor 2. Eingabe: Anzahl der Koeffizienten als int und dann alle Koeffizienten als double
  101.     if (x==0) { // Nullpolynom
  102.         grad=-8; a=new double[1]; a[0]=0.0;
  103.     }
  104.     else {
  105.         double *b = new double[x];
  106.         double doublepar;
  107.         va_list koeffs;
  108.         va_start(koeffs, x);
  109.         for (int i=0; i<x; i++) { // va in Array b speichern
  110.             doublepar = va_arg(koeffs, double);
  111.             b[i] = doublepar;
  112.         }
  113.         for (int i=x-1; i>=0; i--) { // führende 0en 'entfernen'
  114.             grad = i;
  115.             if (b[i] != 0.0) {
  116.                 i=-1;
  117.             }
  118.         }
  119.         if (grad == 0.0 && b[0] == 0.0) { // Nullpolynom
  120.             grad=-8; a=new double[1]; a[0]=0.0;
  121.         }
  122.         else {
  123.             a=new double[grad+1];
  124.             for (int i=0; i<grad+1; i++) { // b ohne führende 0en in a speichern
  125.                 a[i] = b[i];
  126.             }
  127.         }
  128.         va_end(koeffs);
  129.     }
  130. }
  131. Polynom::Polynom(const Polynom &g) { // Copy-Konstruktor
  132.     grad=g.grad;
  133.     if (grad==-8) {
  134.      a=new double[1]; a[0]=0.0;
  135.     }  
  136.     else {
  137.         a=new double[grad+1];
  138.         for (int i=0; i<=grad; i++) {
  139.                 a[i] = g.a[i];
  140.         }
  141.     }
  142. }
  143. Polynom::~Polynom() { // Destruktor
  144.     delete[] a;
  145. }
  146.  
  147. int Polynom::get_grad() { // O(1)
  148.     return grad;
  149. }
  150.  
  151. void Polynom::AusgabeG() { // a_0 * x^0 + a_1 *x^1 + ... + a_n * x^n, inkl. 0 * x^i
  152.     if (a[0] < 0)
  153.         cout << "- " << -a[0] << " * x^" << 0;
  154.     else
  155.         cout << a[0] << " * x^" << 0;
  156.     for (int i = 1; i <= grad; i++) {
  157.         if (a[i] < 0)
  158.             cout << " - " << -a[i] << " * x^" << i;
  159.         else // a[i] >= 0
  160.             cout << " + " << a[i] << " * x^" << i;
  161.     }
  162. }
  163.  
  164. void Polynom::AusgabeGU() { // a_n * x^n + ... + a_1 * x^1 + a_0 * x^0, inkl. 0 * x^i
  165.     if (grad==-8) cout << "0";
  166.     else {
  167.         if (a[grad] < 0)
  168.             cout << "- " << -a[grad] << " * x^" << grad;
  169.         else
  170.             cout << a[grad] << " * x^" << grad;
  171.         for (int i=grad-1; i>=0; i--) {
  172.             if (a[i] < 0)
  173.                 cout << " - " << -a[i] << " * x^" << i;
  174.             else // a[i] >= 0
  175.                 cout << " + " << a[i] << " * x^" << i;
  176.         }
  177.     }
  178. }
  179.  
  180. void Polynom::Ausgabe() { // a_0 + a_1 * x + ... + a_i * x^i + ... + a_n * x^n, sofern a_j != 0
  181.     if (grad==-8) cout << "0";
  182.     else if (a[0] != 0) {
  183.         if (a[0] < 0)
  184.             cout << "- " << -a[0];
  185.         else if (a[0] > 0)
  186.             cout << a[0];
  187.         if (grad >= 1) {
  188.             if (a[1] < 0)
  189.                 cout << " - " << -a[1] << " * x";
  190.             else if (a[1] > 0)
  191.                 cout << " + " << a[1] << " * x";
  192.         }
  193.         for (int i=2; i<grad+1; i++) {
  194.             if (a[i] < 0)
  195.                 cout << " - " << -a[i] << " * x^" << i;
  196.             else if (a[i] > 0)
  197.                 cout << " + " << a[i] << " * x^" << i;
  198.             // else: a[i] = 0 => 0*x^i=0
  199.         }
  200.     }
  201.     else {
  202.         int s=0;
  203.         for (int i=0; i<=grad; i++) {
  204.             s=i;
  205.             if (a[i] != 0) i=grad+1;
  206.         }
  207.        
  208.         if (s==0) {
  209.             if (a[0] < 0)
  210.                 cout << "- " << -a[0];
  211.             else if (a[0] > 0)
  212.                 cout << a[0];
  213.             if (grad >= 1) {
  214.                 if (a[1] < 0)
  215.                     cout << " - " << -a[1] << " * x";
  216.                 else if (a[1] > 0)
  217.                     cout << " + " << a[1] << " * x";
  218.             }
  219.             s=1;
  220.         }
  221.         else if (s==1) {
  222.             if (a[1] < 0)
  223.                 cout << "- " << -a[1] << " * x";
  224.             else if (a[1] > 0)
  225.                 cout << a[1] << " * x";
  226.         }
  227.         else {
  228.             if (a[s] < 0)
  229.                 cout << "- " << -a[s] << " * x^" << s;
  230.             else if (a[s] > 0)
  231.                 cout << a[s] << " * x^" << s;
  232.         }
  233.         for (int i=s+1; i<=grad; i++) {
  234.             if (a[i] < 0)
  235.                 cout << " - " << -a[i] << " * x^" << i;
  236.             else if (a[i] > 0)
  237.                 cout << " + " << a[i] << " * x^" << i;
  238.             // else: a[i] = 0 => 0*x^i=0
  239.         }
  240.     }
  241. }
  242.  
  243. void Polynom::AusgabeU() { // a_n * x^n + ... + a_i * x^i + ... + a_1 * x + a_0, sofern a_j != 0
  244.     if (grad==-8) cout << "0";
  245.     else if (grad==0) {
  246.         if (a[0] < 0)
  247.             cout << "- " << -a[0];
  248.         else if (a[0] > 0)
  249.             cout << a[0];
  250.     }
  251.     else if (grad==1) {
  252.         if (a[1] < 0)
  253.             cout << "- " << -a[1] << " * x";
  254.         else if (a[1] > 0)
  255.             cout << a[1] << " * x";
  256.         if (a[0] < 0)
  257.             cout << " - " << -a[0];
  258.         else if (a[0] > 0)
  259.             cout << " + " << a[0];
  260.     }
  261.     else {
  262.         if (a[grad] < 0)
  263.             cout << "- " << -a[grad] << " * x^" << grad;
  264.         else if (a[grad] > 0)
  265.             cout << a[grad] << " * x^" << grad;
  266.         for (int i=grad-1; i>=2; i--) {
  267.             if (a[i] < 0)
  268.                 cout << " - " << -a[i] << " * x^" << i;
  269.             else if (a[i] > 0)
  270.                 cout << " + " << a[i] << " * x^" << i;
  271.             // else: a[i] = 0 => 0*x^i=0
  272.         }
  273.         if (a[1] < 0)
  274.             cout << " - " << -a[1] << " * x";
  275.         else if (a[1] > 0)
  276.             cout << " + " << a[1] << " * x";
  277.         if (a[0] < 0)
  278.             cout << " - " << -a[0];
  279.         else if (a[0] > 0)
  280.             cout << " + " << a[0];
  281.     }
  282. }
  283.  
  284. bool Polynom::gleich(Polynom g) { // if (f==g)?; worst-case: O(grad)
  285.         if (grad != g.grad) return false;
  286.         for (int i=0; i<=grad; i++)
  287.             if (a[i] != g.a[i]) return false;
  288.         return true;
  289. }
  290.  
  291. bool Polynom::ungleich(Polynom g) { // if (f!=g)?; worst-case: O(grad)
  292.         if (grad != g.grad) return true;
  293.         for (int i=0; i<=grad; i++)
  294.             if (a[i] != g.a[i]) return true;
  295.         return false;
  296. }
  297.  
  298. bool Polynom::Achsensymmetrisch() { // Achsensymmetrisch zur y-Achse; a_0 * x^0 + a_2 * x^2 + ... + a_(2k) * x^(2k); O(grad/2)
  299.     for (int i=1; i<=grad; i=i+2)
  300.         if (a[i] != 0) return false;
  301.     return true;
  302. }
  303.  
  304. bool Polynom::Punktsymmetrisch() { // Punktsymmtrisch zum Ursprung; a_1 * x^1 + a_3 * x^3 + ... + a_(2k+1) * x^(2k+1); O(grad/2)
  305.     for (int i=0; i<=grad; i=i+2)
  306.         if (a[i] != 0) return false;
  307.     return true;
  308. }
  309.  
  310. double potenz(double a, int b) {    // a € |R, b € |N
  311.     if (a == 0 || a == 1) return a; // mit der normalen Berechnung abgedeckt, aber für a^n bei n->unendlich schneller
  312.     if (b == 1) return a;
  313.     else if (b == 2) return a*a;
  314.     else if (b%2==0) return potenz((potenz(a,(int)b/2)),2);
  315.     else return a*potenz((potenz(a,(int)(b-1)/2)),2);
  316.  
  317. /* double potenz(double a, int b) { // a € |R, b € /Z
  318.     if (a == 0 && b == 0) throw 2;      // Fehler: 0^0
  319.     else if (a == 0 && b < 0) throw 1;  // Fehler: 0^b=1/(0^(-b))=1/0
  320.     else if (a == 0 || a == 1) return a; // mit der normalen Berechnung abgedeckt, aber für a^n bei n->unendlich schneller
  321.     else if (b >= 0) {
  322.         if (b==0) return 1;
  323.         else if (b == 1) return a;
  324.         else if (b == 2) return a*a;
  325.         else if (b%2==0) return potenz((potenz(a,(int)b/2)),2);
  326.         else return a*potenz((potenz(a,(int)(b-1)/2)),2);
  327.     }
  328.     else return(1.0/potenz(a,-b)); // b<0; Ergebnis selbst bei a,b € Z nicht mehr in Z => double
  329.    
  330.         try {
  331.             cout << "potenz(" << a << ", " << b << ") = " << potenz(a,b) << endl << endl;
  332.         }
  333.         catch(int e) {
  334.             if (e == 2)
  335.                 cout << "0^0 nicht bzw. unterschiedlich definiert.\n" << endl;
  336.             else // if (e == 1)
  337.                 cout << a << "^(" << b << ") = 1/(0^" << -b << ") = 1/0, d.h. Division durch Null.\n" << endl;
  338.         }  
  339. }   */
  340. }
  341. double Polynom::AuswertungT(double u) { // triviale/einfache/gewöhnliche Auswertung
  342.     if (grad == -8) return 0;
  343.     else if (grad == 0 || u == 0.0) return a[0];
  344.     else if (u == 1.0) { // & Grad > 0
  345.             double sum = a[0];
  346.             for (int i = 1; i <= grad; i++)
  347.                 sum = sum + a[i];
  348.             return sum;
  349.     }
  350.     else { // Grad > 0 & (u!=0 & u!=1)
  351.         double erg = a[0];
  352.         for (int i = 1; i <= grad; i++) {
  353.             erg = erg + a[i] * potenz(u,i); // potenz(u,i) = u^i; 0<i € |N
  354.         }
  355.         return erg;
  356.     }
  357. }
  358.  
  359. double Polynom::Auswertung(double u) { // Auswertung nach Horner-Schema
  360.     if (grad == -8) return 0;
  361.     else if (grad == 0 || u == 0.0) return a[0];
  362.     else if (u == 1.0) { // & Grad > 0
  363.             double sum = a[0];
  364.             for (int i = 1; i <= grad; i++)
  365.                 sum = sum + a[i];
  366.             return sum;
  367.     }
  368.     else { // Grad > 0 & (u!=0 & u!=1)
  369.         double erg = a[grad];
  370.         for (int i = grad-1; i >= 0; i--)
  371.             erg = erg * u + a[i]; // Grad(f) Additionen & Multiplikationen, also 2*Grad(f) Rechenoperationen
  372.         return erg;
  373.     }
  374. }
  375.  
  376. Polynom Polynom::Addition(Polynom g) { // f+g (=g+f)
  377.     if (grad == -8) return Polynom(g);
  378.     else if (g.grad == -8) return Polynom(*this);
  379.     else if (grad > g.grad) {
  380.         double h[grad+1];
  381.         for (int i=0; i<=g.grad; i++)
  382.             h[i] = a[i] + g.a[i];
  383.         for (int i=g.grad+1; i<=grad; i++)
  384.             h[i] = a[i];
  385.         return Polynom(grad+1,h);
  386.     }
  387.     else {
  388.         double h[g.grad+1];
  389.         for (int i=0; i<=grad; i++)
  390.             h[i] = a[i] + g.a[i];
  391.         for (int i=grad+1; i<=g.grad; i++)
  392.             h[i] = g.a[i];
  393.         return Polynom(g.grad+1,h);
  394.     }
  395. }
  396.  
  397. Polynom Polynom::Minus() { // f -> -f
  398.     if (grad == -8) return Polynom(0);
  399.     else {
  400.         double h[grad+1];
  401.         for (int i=0; i<=grad; i++)
  402.             h[i] = -a[i];
  403.         return Polynom(grad+1,h);
  404.     }
  405. }
  406.  
  407. Polynom Polynom::Substraktion(Polynom g) { // f-g (=f+(-g))
  408.     if (g.grad == -8) { // f-0 = f
  409.         Polynom h(*this);
  410.         return h;
  411.     }
  412.     else if (grad == -8) { // & Grad(g) != -(unendlich); ^= h = 0-g = -g
  413.         double h[g.grad+1];
  414.         for (int i=0; i<=g.grad; i++)
  415.             h[i] = -g.a[i];
  416.         return Polynom(g.grad+1,h);
  417.     }
  418.     else if (grad > g.grad) {
  419.         double h[grad+1];
  420.         for (int i=0; i<=g.grad; i++)
  421.             h[i] = a[i] - g.a[i];
  422.         for (int i=g.grad+1; i<=grad; i++)
  423.             h[i] = a[i];
  424.         return Polynom(grad+1,h);
  425.     }
  426.     else {
  427.         double h[g.grad+1];
  428.         for (int i=0; i<=grad; i++)
  429.             h[i] = a[i] - g.a[i];
  430.         for (int i=grad+1; i<=g.grad; i++)
  431.             h[i] = -g.a[i];
  432.         return Polynom(g.grad+1,h);
  433.     }
  434. }
  435.  
  436. Polynom Polynom::SubstraktionAlt(Polynom g) {
  437.     return (*this).Addition(g.Minus());
  438. }
  439.  
  440. // Polynom Polynom::Multiplikation(Polynom g) { // f*g (=g*f) }
  441. // Polynom Polynom::Division(Polynom g) { // f:g v f/g }
  442. // Polynom[] Polynom::Faktorisierung() { }
  443. // double [] Polynom::Nullstellen() { }
  444. // Polynombrüche, wie 1/x = x^1 usw.
  445.  
  446. bool Polynom::operator == (const Polynom& g) {
  447.         if (grad != g.grad) return false;
  448.         for (int i=0; i<=grad; i++)
  449.             if (a[i] != g.a[i]) return false;
  450.         return true;
  451. }
  452.  
  453. bool Polynom::operator != (const Polynom& g) {
  454.         if (grad != g.grad) return true;
  455.         for (int i=0; i<=grad; i++)
  456.             if (a[i] != g.a[i]) return true;
  457.         return false;
  458. }
  459.  
  460. Polynom Polynom::operator = (const Polynom& g) {
  461.     grad=g.grad;
  462.     if (grad==-8) {
  463.      a=new double[1]; a[0]=0.0;
  464.     }
  465.     else {
  466.         a=new double[grad+1];
  467.         for (int i=0; i<=grad; i++) {
  468.                 a[i] = g.a[i];
  469.         }
  470.     }
  471. }
  472.  
  473. Polynom Polynom::operator + (const Polynom& g) {
  474.     if (grad == -8) return Polynom(g);
  475.     else if (g.grad == -8) return Polynom(*this);
  476.     else if (grad > g.grad) {
  477.         double h[grad+1];
  478.         for (int i=0; i<=g.grad; i++)
  479.             h[i] = a[i] + g.a[i];
  480.         for (int i=g.grad+1; i<=grad; i++)
  481.             h[i] = a[i];
  482.         return Polynom(grad+1,h);
  483.     }
  484.     else {
  485.         double h[g.grad+1];
  486.         for (int i=0; i<=grad; i++)
  487.             h[i] = a[i] + g.a[i];
  488.         for (int i=grad+1; i<=g.grad; i++)
  489.             h[i] = g.a[i];
  490.         return Polynom(g.grad+1,h);
  491.     }
  492. }
  493.  
  494. Polynom Polynom::operator - () {
  495.     if (grad == -8) return Polynom(0);
  496.     else {
  497.         double h[grad+1];
  498.         for (int i=0; i<=grad; i++)
  499.             h[i] = -a[i];
  500.         return Polynom(grad+1,h);
  501.     }
  502. }
  503.  
  504. Polynom Polynom::operator - (const Polynom& g) {
  505.     if (g.grad == -8) { // f-0 = f
  506.         Polynom h(*this);
  507.         return h;
  508.     }
  509.     else if (grad == -8) { // & Grad(g) != -(unendlich); ^= h = 0-g = -g
  510.         double h[g.grad+1];
  511.         for (int i=0; i<=g.grad; i++)
  512.             h[i] = -g.a[i];
  513.         return Polynom(g.grad+1,h);
  514.     }
  515.     else if (grad > g.grad) {
  516.         double h[grad+1];
  517.         for (int i=0; i<=g.grad; i++)
  518.             h[i] = a[i] - g.a[i];
  519.         for (int i=g.grad+1; i<=grad; i++)
  520.             h[i] = a[i];
  521.         return Polynom(grad+1,h);
  522.     }
  523.     else {
  524.         double h[g.grad+1];
  525.         for (int i=0; i<=grad; i++)
  526.             h[i] = a[i] - g.a[i];
  527.         for (int i=grad+1; i<=g.grad; i++)
  528.             h[i] = -g.a[i];
  529.         return Polynom(g.grad+1,h);
  530.     }
  531. }
  532.  
  533. // Polynom Polynom::operator * (const Polynom& g) {}
  534. // Polynom Polynom::operator / (const Polynom& g) {}
  535.  
  536. /* ostream& operator<<(ostream& Stream, const Bruch& B) {
  537.     return Stream << B.Zaehler() << "/" << B.Nenner();
  538. } */
  539.  
  540. Polynom Polynom::Ableitung() { // f -> f'
  541.     if (grad == -8 || grad == 0) { // f(x)=0 v f(x)=c => f'(x)=0
  542.         return Polynom(0);
  543.     }
  544.     else {
  545.         double abl[grad];
  546.         abl[0] = a[1];
  547.         for (int i=1; i<=grad; i++)
  548.             abl[i] = (i+1.0)*a[i+1];
  549.         return Polynom(grad,abl);
  550.     }
  551. }
  552.  
  553. Polynom Polynom::Stammfunktion() { // f -> F
  554.     if (grad == -8) { // f(x)=0 => F(x)=0(+c)
  555.         return Polynom(0);
  556.     }
  557.     else {
  558.         double sta[grad+2];
  559.         sta[0] = 0; // (+c)
  560.         for (int i=1; i<=grad+1; i++)
  561.             sta[i] = (1.0/i)*a[i-1];
  562.         return Polynom(grad+2,sta);
  563.     }
  564. }
  565.  
  566. double Polynom::Integral(double untereGrenze, double obereGrenze) { // a=untereGrenze, obereGrenze=b
  567.     if (untereGrenze == obereGrenze) return 0.0; // aS^a f(x) dx = F(a) - F(a) = 0
  568.     else if (untereGrenze > obereGrenze) { // a > b => Integral: - (bS^a f(x) fx) = - (F(a) - F(b))
  569.         Polynom F = (*this).Stammfunktion();
  570.         return( - (F.Auswertung(untereGrenze) - F.Auswertung(obereGrenze)) );
  571.     }
  572.     else { // a < b => Integral: aS^b f(x) dx = F(b) - F(a)
  573.         Polynom F = (*this).Stammfunktion();
  574.         return(F.Auswertung(obereGrenze) - F.Auswertung(untereGrenze));
  575.     }
  576. }
  577.  
  578.  
  579. // main.cpp
  580. int main() {
  581.     // Konstruktoren
  582.     Polynom a(2,3.3,5.7); Polynom b(3,6.5,-1.5,2.3); Polynom c(1,2.7);
  583.     Polynom d(0); Polynom e(2,0.0,0.0,0.0); Polynom f(6,8.4,0.0,1.7,-2.3,3.2,0.0);
  584.     Polynom f2(6,0.0,0.0,-1.2,0.0,3.2); Polynom g(3,3.3,5.7,0.0); Polynom h1(e);
  585.     Polynom h2 = b;  Polynom h3; double ii[]={4.5,7.1,3.4}; Polynom i(3,ii);
  586.     //Ausgabe
  587.     a.Ausgabe(); cout<<endl; b.Ausgabe(); cout<<endl; c.AusgabeU(); cout<<endl;
  588.     d.Ausgabe(); cout<<endl; e.AusgabeG(); cout<<endl; f.AusgabeU(); cout<<endl;
  589.     f2.Ausgabe(); cout<<endl; g.AusgabeG(); cout<<endl; h1.Ausgabe(); cout<<endl;
  590.     h2.AusgabeGU(); cout<<endl; h3.Ausgabe(); cout<<endl; i.Ausgabe(); cout<<"\n"<<endl;
  591.     // gleich/ungleich?
  592.     cout<< a.gleich(b) <<" "<< d.gleich(e) <<" "<< g.gleich(a) <<" "<< a.ungleich(g) <<"\n"<<endl;
  593.     // Auswertung
  594.     cout<< potenz(2,4) <<" "<< potenz(3,3) <<endl;
  595.     cout<< d.AuswertungT(0) <<" "<< a.AuswertungT(1) <<" "<< a.AuswertungT(0);
  596.       cout<<" "<< a.Auswertung(-2) <<" "<< f2.Auswertung(2) <<endl;
  597.     cout<< d.Auswertung(0) <<" "<< a.Auswertung(1) <<" "<< a.Auswertung(0);
  598.       cout<<" "<< a.Auswertung(-2) <<" "<< f2.Auswertung(2) <<"\n"<<endl;
  599.     // Symmetrie
  600.     cout<< a.Achsensymmetrisch() <<" "<< a.Punktsymmetrisch() <<" ";
  601.       cout<< e.Achsensymmetrisch() <<" "<< d.Punktsymmetrisch() <<endl;
  602.     Polynom s1(6,0.0,1.0,0.0,3.4,0.0,0.3); Polynom s2(4,0.5,0.0,3.2,0,0,8.7);
  603.     cout<< s1.Achsensymmetrisch() <<" "<< s1.Punktsymmetrisch() <<" ";
  604.       cout<< s2.Achsensymmetrisch() <<" "<< s2.Punktsymmetrisch() <<"\n"<<endl;
  605.     // Addition
  606.     (a.Addition(c)).Ausgabe(); cout<<endl; (a.Addition(e)).Ausgabe(); cout<<endl;
  607.     (b.Addition(a.Addition(c))).Ausgabe(); cout<<endl; (a.Addition(b)).Ausgabe(); cout<<"\n"<<endl;
  608.     // Minus
  609.     Polynom m(a.Minus()); a.Ausgabe(); cout<<endl; m.Ausgabe(); cout<<endl;
  610.     (a.Minus()).Ausgabe(); cout<<endl; a.Ausgabe(); cout<<"\n"<<endl;
  611.     // Substraktion
  612.     (a.Substraktion(f)).Ausgabe(); cout<<endl; (f.Substraktion(a)).Ausgabe(); cout<<endl;
  613.     (a.Substraktion(a)).Ausgabe(); cout<<endl; (e.Substraktion(a)).Ausgabe(); cout<<endl;
  614.     (a.Substraktion(e)).Ausgabe(); cout<<endl;
  615.     (a.SubstraktionAlt(a)).Ausgabe(); cout<<endl; a.Ausgabe(); cout<<endl;
  616.     (e.SubstraktionAlt(a)).Ausgabe(); cout<<endl; (a.SubstraktionAlt(e)).Ausgabe(); cout<<endl;
  617.     (f.SubstraktionAlt(b)).Ausgabe(); cout<<endl;cout<<"\n"<<endl;
  618.     // Ableitung
  619.     (e.Ableitung()).Ausgabe(); cout<<" <- "; e.Ausgabe(); cout<<endl;
  620.     (a.Ableitung()).Ausgabe(); cout<<" <- "; a.Ausgabe(); cout<<endl;
  621.     (f.Ableitung()).AusgabeU(); cout<<" <- "; f.AusgabeU(); cout<<"\n"<<endl;
  622.     // Stammfunktion
  623.     (e.Stammfunktion()).Ausgabe(); cout<<" <- "; e.Ausgabe(); cout<<endl;
  624.     (a.Stammfunktion()).AusgabeU(); cout<<" <- "; a.AusgabeU(); cout<<"\n"<<endl;
  625.     // Integral
  626.     Polynom i1(1,2.0);
  627.     cout << i1.Integral(0.0, 4.0) <<" "<< i1.Integral(4.0,0.0) <<" "<< a.Integral(3,3) <<"\n"<<endl;
  628.     // Operatoren
  629.     cout << (a==b) <<" "<< (b==a) <<" "<< (a!=b) <<" "<< (a==g) <<" "<< (g!=a) << endl;
  630.     (a+f).Ausgabe(); cout<<endl; (a.Addition(f)).Ausgabe(); cout<<endl;
  631.     (a-b).Ausgabe(); cout<<endl; (-a).Ausgabe(); cout<<endl; Polynom a2 = a; a2.Ausgabe(); cout<<endl;
  632.     Polynom o; o=f; o.Ausgabe(); cout<<"\n"<<endl;
  633. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!