#include "stdafx.h"



/*
 Ta struktura posłuży jako wynik sumowania, oprócz wartości
 będzie informować użytkownika o tym, cyz przekroczono
 dopuszczalną liczbę wyrazów rozwinięcia szeregu oraz czy
 osiągnięto zadaną przez użytkownika dokładność.
*/

struct WynikSumowania
{
    double suma;
    bool osiagnietoDokladnosc;
    bool przekroczonoMaksWyrazow;
};

/* funkcja zamienia dwie wartości typu double)
   znak & (ampersand) informuje kompilator, żeby przekazał referencję do
   zmiennych do funkcji, zamiast kopii tychże zmiennych.
*/
void zamien(double &x, double &y)
{
    double tymczasowy = x;
    x = y;
    y = tymczasowy;
}


/*
 Ta struktura będzie naszym przedziałem.
 nazwy pól są intuicyjne (oby.)
*/
struct Przedzial
{
    double poczatek, koniec;
};


/*********************************************************
 * f(x) - oblicza wartośc funkcji dla argumentu x
 *
 ********************************************************/
double f(double x)
{

    //funkcja zwraca wartośc równą:
    //             1
    // f(x) =   -------
    //          (1-x^2)
    return x/(1-(x*x));
};

/*********************************************************
 * suma(x,e,epsilon) - oblicza wartość funkcji za pomocą szeregu
 * funkcja przerywa sumowanie, gdy:
 * -> liczba wyrazów w
 *    rozwinięciu przekroczy liczbę podaną jako argument 'e'
 *
 * -> zostanie osiągnięta dokładność (przekazana przez zmienną epsilon)
 *
 ********************************************************/
WynikSumowania suma(double x, unsigned int e, double epsilon)
{
    int n = 1; //zaczynamy od obliczenia jednego wyrazu.
    double suma = 0; //na początku suma jest równa 0.
    WynikSumowania wynik; //to będzie nasz wynik.

    do
    {
        suma += n*(pow(x,n-1));
        // do obecnej wartości sumy dodajemy:
        //
        //  n * x^{n-1}
        //

    } while ((n < e) && (abs(suma) > abs(epsilon)));
    /* powyższy warunek składa się z koniunkcji dwóch
     * mniejszych warunków:
     * ->  n < e (sprawdzam czy nie przekroczono dozwolonej liczby
     *     wyrazów.
     *
     * -> abs(sum) > abs(epsilon) (sprawdzam czy moduł obecnej wartości
     *    sumy jest większy od modułu epsilon (epsilon jest w module
     *    na wypadek gdyby jakiś idiota podał ujemną wartość epsilon).
     *    Dopóki oba warunki są spełnione - czyli nie przekroczono maksymalnej
     *    ilości wyrazów, i nie osiągnięto zadanej dokładności, dopóty powyższa
     *    pętla będzie się wykonywać. (korzystając z własności koniunkcji, gdy
     *    którykolwiek z warunków jest niespełniony - czyli osiągnięto zadaną
     *    dokładność LUB <z praw de Morgana - zaprzeczeniem koniunkcji jest alternaty-
     *    -wa zaprzeczeń> przekroczono maksymalną liczbę wyrazów, wtedy pętla zakoń-
     *    -czy  działanie. teraz pozostaje wypełnić strukturę typu wynikSumowania,
     *    która będzie zwróconą wartością. ;-)
     *
     */


    wynik.przekroczonoMaksWyrazow = n > e;
    wynik.osiagnietoDokladnosc = (abs(suma) > abs(epsilon));
    /* powyższe wyrażenia korzystają z tego, że operatory porównania zwracają
       wartość typu bool (true/false) i wynik tych porównań zostaje zapisany
       w polach struktury 'wynik'
    */

    wynik.suma = suma;
    /* zapisujemy w odpowiednim polu struktury 'wynik' sumę, jaka została nam pod
       koniec obliczeń
    */

    return wynik; //ostatecznie - zwracamy wynik do funkcji wywołującej.

};

double* generuj_tablice(Przedzial  przedzial, double dx)
{
    dx = abs(dx); // na wypadek, gdyby ktoś mądry podał ujemną wartość.

    //jesli ktos podal poczatek przedzialu, ktory jest 'fizycznie'
    // za jego koncem, to też poprawmy to.
    if (przedzial.poczatek > przedzial.koniec)
        zamien(przedzial.poczatek,przedzial.koniec);

    //gdyby początek i koniec przedziału były sobie równe, to rozmiarTab byłby równy
    // 0, i by nie było wyników... ;-)
    else if (przedzial.poczatek == przedzial.koniec)
        przedzial.koniec = przedzial.poczatek + 10;


    //zaczynamy generowac tablicę od poczatku przedziału.
    double x = przedzial.poczatek;


    //obliczmy ile elementów będzie mieć tablica...
    int rozmiarTab = (przedzial.koniec - przedzial.poczatek) / dx;


    if (rozmiarTab > 0)
    {
        if (tablica != NULL) delete tablica;
        //teraz przydzielmy dla niej pamięć.
        double* tablica = new double[rozmiarTab];

        if (tablica != NULL)    //jeśli przydzielenie się powiodło,to...
        {
            // w pętli obliczamy wartośc dla każdego elementu x
            // (zaczynając od x = przedzial.poczatek)
            for (int i=0; i< rozmiarTab;i++)
            {
                tablica[i] = f(x);
                x += dx; //nastepny x będzie równy x + dx,więc dodajemy dx.
            };
        };
        return tablica;
    }
    else return NULL; //w przeciwnym wypadku zwracamy NULL, żeby poinformować użytkownika,
    //że coś poszło nie tak.



};





int _tmain(int argc, _TCHAR* argv[])
{
    Przedzial przedzial = {0.5,0.9};
    double dx  = 0.01;
    int rozmiar = generuj_tablice(przedzial,dx,t);
    delete t;

    return 0;
}