Public paste
Undefined
By: mathfunctions.cpp | Date: Nov 28 2009 14:57 | Format: C++ | Expires: never | Size: 3.23 KB | Hits: 522

  1. //////////////////////////////////////////////////////////////////////////
  2. //                                                                                                                                              //
  3. // Voelz, Michael                                    Matr.-Nr.: 345451  //
  4. //                                                                                                                                              //
  5. //                                                                                                                                              //
  6. // modCalc                                                                                                              //
  7. // =========                                                                                                                    //
  8. //                                                                                                                                              //
  9. //////////////////////////////////////////////////////////////////////////
  10. //                                                                                                                                              //
  11. // Datum: 19.11.2006                                                                                                    //
  12. //                                                                                                                                              //
  13. //                                                                                                                                              //
  14. //                                                                                                                                              //
  15. //                                                                                                                                              //
  16. // Beschreibung des Programms:                                                                                  //
  17. // ===========================                                                                                  //
  18. //                                                                                                                                          //
  19. // Funktion:                                                                                                                    //
  20. // Fordert zur Eingabe eines Operators und eines Operanden auf und              //
  21. // gibt dann das ergebnis aus. Division durch 0 ist nicht erlaubt.              //
  22. // Beenden mit 'e'. L�schen mit 'c'.                                                                     //
  23. //                                                                                                                                          //
  24. // Aufbau:                                                              //
  25. // enth�lt eine do-while Schleife in der die Berechnung und die         //
  26. // Abfrage stattfindet. Am Anfang ein if um auf Eingabe von 'e'                 //
  27. // oder 'c' zu �berpr�fen.                                                                                                //
  28. //                                                                                                                                          //
  29. // Benutzung:                                                                                                           //
  30. // einfach nur starten und den Anweisungen folgen                       //
  31. //                                                                                                                                              //
  32. //                                                                                                                                              //
  33. //                                                                                                                                              //
  34. //////////////////////////////////////////////////////////////////////////
  35. #include <iostream>
  36. #include "mathfunctions.h" // headerfile
  37. using namespace std;
  38.  
  39. double potenz(double basis, int pot) // wenn potenz gr&#65533;&#65533;er 0, normale potenz. wenn 0, dann 1. sonst negative potenzrechnung.
  40. {
  41.         double potzwischen = 1;
  42.         if (pot > 0)
  43.         {
  44.                 for (int i=1; i<=pot; i++) // normal
  45.                 {
  46.                         potzwischen = potzwischen * basis;
  47.                 }
  48.         }
  49.         else
  50.         {
  51.                 if (pot == 0)
  52.                 {
  53.                         potzwischen = 1; // potenz = 0
  54.                 }
  55.                 else
  56.                 {
  57.                         pot = pot * -1; // wenn negative potenz
  58.                         for (int i=1; i<=pot; i++)
  59.                         {
  60.                                 potzwischen = potzwischen * basis;
  61.                         }
  62.                         potzwischen = 1 / potzwischen;                 
  63.                 }              
  64.         }
  65.         return(potzwischen);
  66. }
  67.  
  68. double fakultaet(double fak) // for-schleife f&#65533;r die fakult&#65533;t mit wenn overflow, dann rel. und abs. fehler ausgeben.
  69. {
  70.         double fakerg2;
  71.         double fakerg = 1;
  72.         double relfehler;
  73.         double absfehler;
  74.         for (double i=1; i<=fak; i++) // fakult&#65533;t
  75.         {
  76.                 fakerg2 = fakerg;
  77.                 fakerg = fakerg * i;
  78.                 absfehler = (fakerg / i) - fakerg2; // wenn kein overflow, dann ist absfehler = 0
  79.                 if (absfehler != 0) // wenn overflow
  80.                 {                      
  81.                         relfehler = absfehler / fakerg2; // relativen fehler wird berechnet
  82.                         cout << "Overflow bei " << i << endl; // wann overflow
  83.                         cout << "relativer Fehler: " << relfehler << endl; // relativen fehler ausgeben
  84.                         cout << "absoluter Fehler: " << absfehler << endl; // absoluten fehler ausgeben
  85.                 }
  86.         }
  87.         return(fakerg);
  88. }
  89.  
  90. bool ganzZahl(double zahl) // ganze zahl?
  91. {
  92.         if (double(int(zahl)) == zahl) // wenn int-wert von zahl = double-wert von zahl, dann true
  93.         {
  94.                 return true; // wenn ganze zahl
  95.         }
  96.         else
  97.         {
  98.                 return false; // wenn keine ganze zahl
  99.         }
  100. }
  101.  
  102. int runden(double wert)
  103. {
  104.         if (wert - int(wert) >= 0.5)
  105.         {
  106.                 return int(wert)+1;
  107.         }
  108.         else
  109.         {
  110.                 return int(wert);
  111.         }
  112. }