fork download 
  1. /*  *   *   *   *   *   *   *   *   *
  2.  *  Zad. 3                          *
  3.  *  Obliczyć sumę szeregu:          *
  4.  *      m                           *
  5.  *      E   z^n,                    *
  6.  *     n=0                          *
  7.  *  gdy z jest liczbą zespoloną.    *
  8.  *  *   *   *   *   *   *   *   *   */
  9.  
  10. #include <stdio.h>
  11.  
  12. ///////////////////////////////////////////////////
  13. /// struktura przedstawiająca liczby zespolone  ///
  14. ///////////////////////////////////////////////////
  15. typedef struct Zespolona                            //  typedef oznacza, że zdefiniujemy alias do struktury
  16. {
  17.     double Re;                                      //  część rzeczywista
  18.     double Im;                                      //  część urojona
  19. } Zespolona;                                        //  alias do struktury Zespolona to Zespolona
  20.  
  21. //////////////////////////////////////////////////////
  22. /// deklaracje funkcji do operacji na strukturze   ///
  23. //////////////////////////////////////////////////////
  24. Zespolona utworz1();                                //  utworzymy zespoloną z klawiatury         
  25. Zespolona utworz2(double, double);                  //  utworzymy zespoloną z argumentów
  26. Zespolona potega(const Zespolona, int);             //  potęga zespolonej
  27. Zespolona dodaj(const Zespolona, const Zespolona);  //  suma dwóch zespolonych
  28. void pokaz(const Zespolona);                        //  pokaz zespolonej
  29.  
  30. ///////////////////////////////////////////////////
  31. /// definicje funkcji do operacji na strukturze ///
  32. ///////////////////////////////////////////////////
  33. Zespolona utworz()
  34. {
  35.     Zespolona Z;                                    //  tworzymy lokalną strukturę Z
  36.  
  37.     printf("Podaj Re: ");                           //  wczytujemy dane do pól struktury
  38.     scanf("%lf", &Z.Re);
  39.  
  40.     printf("Podaj Im: ");
  41.     scanf("%lf", &Z.Im);
  42.  
  43.     return Z;                                       //  zwracamy strukturę
  44. }
  45.  
  46. Zespolona utworz2(double re, double im)
  47. {
  48.     Zespolona Z;
  49.  
  50.     Z.Re = re;                                      //  przypisujemy wartości polom struktury
  51.     Z.Im = im;
  52.  
  53.     return Z;
  54. }
  55.  
  56. Zespolona potega(const Zespolona Z1, int i)         //  argumentami jest stała struktura i jej potęga
  57. {                                                   //  const oznacza, że nie możemy w tej funkcji zmienić wartości
  58.     Zespolona Z;                                    //  struktury Z1, tekie zabezpieczenie przed utratą danych
  59.  
  60.     if (i == 0)                                     //  (a + bi)^0 = 1 + 0i
  61.     {
  62.         Z.Re = 1;
  63.         Z.Im = 0;
  64.     }
  65.     else
  66.     {
  67.         Z.Re = Z1.Re;                               //  (a + bi)^1 = a + bi
  68.         Z.Im = Z1.Im;
  69.  
  70.         ///////////////////////////////////////////////
  71.         /// (a + bi)(c + di) = ac - bd + adi + bci  ///
  72.         ///                                         ///
  73.         /// (1 + i)(1 + i) = 1 + i + i - 1 = 0 + 2i ///
  74.         ///////////////////////////////////////////////
  75.         int j;
  76.         for (j = 1; j < i; j++)                     //  pętla od 1 bo powyżej policzyliśmy potęgę 1
  77.         {
  78.             Z = utworz2(Z.Re*Z1.Re - Z.Im*Z1.Im, Z.Re*Z1.Im + Z.Im*Z1.Re);
  79.         }
  80.     }
  81.  
  82.     return Z;
  83. }
  84.  
  85. Zespolona dodaj(const Zespolona Z1, const Zespolona Z2) //  argumentami są dwie stałe struktury
  86. {
  87.     Zespolona Z;
  88.  
  89.     Z.Re = Z1.Re + Z2.Re;                           //  przypisanie polom struktury lokalnej sumy składowych dwóch
  90.     Z.Im = Z1.Im + Z2.Im;                           //  liczb zespolonych
  91.  
  92.     return Z;
  93. }
  94.  
  95. void pokaz(const Zespolona Z)
  96. {
  97.     printf("%.4lf + %.4lfi\n", Z.Re, Z.Im);         //  wypisanie na ekran zespolonej
  98. }
  99.  
  100. int main()
  101. {
  102.     Zespolona Z1 = utworz();                        //  tworzymy zespoloną z klawiatury
  103.     int m;                                          //  składowa sumy
  104.  
  105.     printf("Podaj m: ");
  106.     scanf("%d", &m);
  107.  
  108.     Zespolona Z = utworz2(1, 0);                    //  struktura wynikowa = Z1^0 = 1 + 0i
  109.  
  110.     int n;
  111.     for (n = 1; n <= m; n++)                        //  pominięte 0, jak wyżej
  112.     {
  113.         Z = dodaj(Z, potega(Z1, n));                //  suma wynikowej oraz potęgi wejściowej
  114.     }
  115.  
  116.     pokaz(Z);                                       //  pokaz wynikowej
  117.  
  118.     return 0;
  119. }
Success #stdin #stdout 0s 2012KB
comments (?)
stdin 
4 -3 8
stdout 
Podaj Re: Podaj Im: Podaj m: 133281.0000 + 440640.0000i
https://ideone.com/9GuNSW
language:
C (gcc 8.3)
created:
9 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!