radical simplifier

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <windows.h>

//Nie udzielam na ten program żadnej gwarancji, używasz go wyłącznie na własne ryzyko.

//wersja alpha, niezoptymalizowana; data ostatniej modyfikacji: 16-02-2014 21:53
using namespace std;

double bezwzgledna(double wejscie){return ((wejscie<0) ? wejscie*(-1) : wejscie);}

double potegowanie(double podstawa, int wykladnik){
    double wynik=1.0;
    bool licz=true;
    bool czy_blad=false;
    bool odwroc_wynik=false;
    if(podstawa==0&&wykladnik==0) {czy_blad=true;licz=false;}
    if(podstawa==0) {wynik=0;licz=false;}
    if(podstawa!=0&&wykladnik==0) {wynik=1;licz=false;}
    if(podstawa!=0&&wykladnik<0) {wykladnik=wykladnik*(-1);odwroc_wynik=true;}
    if(licz==true) {
        for(int i=1;i<=wykladnik;i++) {
            wynik=wynik*podstawa;
        }
        if(odwroc_wynik==true) {wynik=1/wynik;}
    } else {
        if(czy_blad==true) {
            return false;
        }
    }
    return wynik;
}

double pierwiastkowanie(int stopien, double wejscie, int precyzja){
    if(stopien<=1) return false;
    if(stopien%2==0&&wejscie<0) return false;
    bool wynik_ze_znakiem=false;
    if(wejscie<0) wynik_ze_znakiem=true;
    int j=0;
    double prec=1;
    double seek=0.0;
    while(1) {
        if(potegowanie(j,stopien)>bezwzgledna(wejscie)) break;
        j+=1;
    }
    j-=1;
    seek=j;
    for(int i=0;i<precyzja;i++){
        prec=prec*0.1;
        while(1){
            seek+=prec;
            if(potegowanie(seek,stopien)>bezwzgledna(wejscie)) break;
        }
        seek-=prec;
    }
    return ((wynik_ze_znakiem==true) ? seek*(-1) : seek);
}

//cls routine by MS: http://support.microsoft.com/kb/99261
int cls(void){
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD coordScreen = { 0, 0 };
    DWORD cCharsWritten;
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    DWORD dwConSize;
    GetConsoleScreenBufferInfo( hConsole, &csbi );
    dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
    FillConsoleOutputCharacter( hConsole, (TCHAR) ' ', dwConSize, coordScreen, &cCharsWritten );
    GetConsoleScreenBufferInfo( hConsole, &csbi );
    FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten );
    SetConsoleCursorPosition( hConsole, coordScreen );
    return 0;
}

void wymaz_z_tablicy(int* tablica, int element, int wystapien, int rozmiar_tab){
    for(int i=0;i<rozmiar_tab;i++){
        if(wystapien==0) break;
        if(tablica[i]==element) {
            tablica[i]=0;
            wystapien-=1;
        }
    }
    return;
}

int main(){
    cout << "\n upraszczacz pierwiastkow arytmetycznych v0.1a\n Copyright (C)2014 Michal Hanebach\n\n ";
    cout << "Ten program jest darmowy. Nie udziela sie nan zadnej gwarancji.\n\n ";
    Sleep(2000);
    cls();

    int kolory[32];
    int domyslne_kolory[]={46,48,55,58,62,63,78,79,87,94,110,111,121,126,128,129,132,133,138,139,142,143};
    //int domyslne_kolory[]={2,3,4,5,6,8,2,3,4,5,6,8,2,3,4,5,6,8,2,3,4,5,6,8};
    //int domyslne_kolory[]={10,14,12,11,13,15,10,14,12,11,13,15,10,14,12,11,13,15,10,14,12,11,13,15};
    for(int i=0;i<32;i++){kolory[i]=0;}
    string linia;
    bool domyslne=false;
    ifstream schemat_kolorow;
    schemat_kolorow.open("schemat_kolorow.ini");
    if(schemat_kolorow.is_open()==true) {
        getline(schemat_kolorow,linia);
        schemat_kolorow.close();
        if(linia[0]=='k'&&linia[1]=='o'&&linia[2]=='l'&&linia[3]=='o'&&linia[4]=='r'&&linia[5]=='y'&&linia[6]=='='){
            int i=0;
            int j=7;
            int m=0;
            int bufor[3];
            int tokens=0;
            bool wyjdz=false;
            int zlepiona_liczba=0;
            while(linia[j]!=0){
                switch(linia[j]){
                    case 44: //ASCII ","
                    for(int k=0;k<3;k++){bufor[k]=0;}
                    tokens+=1;
                    if(tokens>32) wyjdz=true;
                    break;

                    default:
                    while(linia[j]!=',') {bufor[m]=linia[j];j+=1;m+=1;if(m>2) {break;}}
                    j-=1;
                    if(bufor[2]<48||bufor[2]>57) { //ASCII "0" "9"
                        zlepiona_liczba=(bufor[1]%16);
                        zlepiona_liczba+=(bufor[0]%16)*10;
                    } else {
                        zlepiona_liczba=bufor[2]%16;
                        zlepiona_liczba+=(bufor[1]%16)*10;
                        zlepiona_liczba+=(bufor[0]%16)*100;
                    }
                    kolory[i]=zlepiona_liczba;
                    i+=1;
                    m=0;
                    break;
                }
                if(wyjdz==true) {break;}
                j+=1;
            }
        }
    } else {domyslne=true;}
    if(domyslne) {copy(domyslne_kolory,domyslne_kolory+26,kolory);}
    do {
    //for(int i=0;i<32;i++){if(kolory[i]!=0){cout << " " << kolory[i];}}
    HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
    /*for(int i=0;i<32;i++){
        if(kolory[i]==0) break;
        cout << "\n";
        SetConsoleTextAttribute(hConsole,kolory[i]);
        for(int j=0;j<5;j++){cout << kolory[i];}
    }*/
    //SetConsoleTextAttribute(hConsole,7);

    int ilosc=0;
    for(int i=0;i<32;i++){if(kolory[i]!=0) {ilosc+=1;}}
    srand(time(NULL));
    int losowe[ilosc];
    int los=0;
    int ilosc_wystapien=0;
    int ilosc_zapisanych=-1;
    for(;ilosc_zapisanych<ilosc-1;){
        los=rand() % ilosc;
        ilosc_wystapien=0;
        for(int j=0;j<ilosc;j++) {
            if(losowe[j]==los) {ilosc_wystapien+=1;}
        }
        if(ilosc_wystapien!=0) continue;
        ilosc_zapisanych+=1;
        losowe[ilosc_zapisanych]=los;
    }
    long int liczba=0;
    int stopien=0;
    cout << "\n Podaj liczbe podpierwiastkowa: ";
    cin >> liczba;
    cout << "\n Podaj stopien pierwiastka: ";
    cin >> stopien;
    if(liczba<0&&stopien%2==0){
        SetConsoleTextAttribute(hConsole,12);
        cout << "\n  Program nie obsluguje jednostki urojonej.\n";
        SetConsoleTextAttribute(hConsole,7);
        continue;
    }
    bool ze_znakiem=false;
    if(liczba<0) {
        SetConsoleTextAttribute(hConsole,14);
        cout << "\n  Do rozkladu zmieniono znak liczby na przeciwny.";
        SetConsoleTextAttribute(hConsole,7);
        ze_znakiem=true;
        liczba*=(-1);
    }
    int pierwsze[100];
    int ilosci_dzielnikow[100];
    int wylaczone_przed_pierwiastek[100];
    int ilosc_do_wymazania[100];
    int unikatowe_dzielniki[100];
    for(int i=0;i<100;i++){
        pierwsze[i]=0;
        ilosci_dzielnikow[i]=0;
        wylaczone_przed_pierwiastek[i]=0;
        ilosc_do_wymazania[i]=0;
        unikatowe_dzielniki[i]=0;
    }
    int indeks_ilosci_dzielnikow=0;
    int powtorzen_dzielnika=0;
    int ostatni_dzielnik=1;
    long int liczba_=liczba;
    int i=0;
    for(;;){
        powtorzen_dzielnika=0;
        ostatni_dzielnik+=1;
        while(liczba_%ostatni_dzielnik==0) {
            powtorzen_dzielnika+=1;
            pierwsze[i]=ostatni_dzielnik;
            i+=1;
            liczba_/=ostatni_dzielnik;
        }
        if(powtorzen_dzielnika!=0) {
            ilosci_dzielnikow[indeks_ilosci_dzielnikow]=powtorzen_dzielnika;
            indeks_ilosci_dzielnikow+=1;
        }
        if(ostatni_dzielnik==liczba) break;
    }
    int indeks_koloru=0;
    ostatni_dzielnik=0;
    int indeks_do_wymazania=0;
    int indeks_wylaczonych=0;
    cout << "\n\n  Rozklad liczby " << liczba << " na czynniki pierwsze:\n\n  ";
    for(int i=0;i<99;i++){
        if(pierwsze[i]!=ostatni_dzielnik) {indeks_koloru+=1;}
        if(pierwsze[i]!=0) {
            SetConsoleTextAttribute(hConsole,kolory[indeks_koloru]);
            cout << pierwsze[i];
            SetConsoleTextAttribute(hConsole,7);
        }
        if(pierwsze[i+1]!=0) {cout << " * ";}
    }
    cout << "\n\n  Rozklad na iloczyn potegowy:\n\n  ";
    bool pierwsza_iteracja=true;
    indeks_koloru=0;
    ostatni_dzielnik=0;
    indeks_ilosci_dzielnikow=0;
    int pomocnicza1=0;
    int pomocnicza2=0;
    for(int i=0;i<99;i++){
        if(pierwsze[i]==ostatni_dzielnik) continue;
        if(pierwsze[i]==0&&pierwsze[i+1]==0) break;
        pomocnicza1=ilosci_dzielnikow[indeks_ilosci_dzielnikow];
        pomocnicza2=0;
        if(pierwsza_iteracja==false) {cout << " * ";}
        pierwsza_iteracja=false;
        SetConsoleTextAttribute(hConsole,kolory[indeks_koloru]);
        cout << pierwsze[i];
        if(ilosci_dzielnikow[indeks_ilosci_dzielnikow]>1) {
            cout << "^" << ilosci_dzielnikow[indeks_ilosci_dzielnikow];
        }
        SetConsoleTextAttribute(hConsole,7);
        indeks_koloru+=1;
        if(ilosci_dzielnikow[indeks_ilosci_dzielnikow]>=stopien) {
            while(pomocnicza1>=stopien) {pomocnicza1-=stopien;pomocnicza2+=1;}
            for(int j=0;j<pomocnicza2;j++){
                wylaczone_przed_pierwiastek[indeks_wylaczonych]=pierwsze[i];
                indeks_wylaczonych+=1;
            }
            ilosc_do_wymazania[indeks_do_wymazania]=pomocnicza2*stopien;
            indeks_do_wymazania+=1;
        }
        indeks_ilosci_dzielnikow+=1;
        ostatni_dzielnik=pierwsze[i];
    }
    bool cos_wylaczone=false;
    for(int i=0;i<100;i++){if(wylaczone_przed_pierwiastek[i]!=0) {cos_wylaczone=true;}}

    if(cos_wylaczone) {
        ostatni_dzielnik=1;
        indeks_do_wymazania=0;
        for(int i=0;i<99;i++){
            if(pierwsze[i]==0&&pierwsze[i+1]==0) break;
            if(pierwsze[i]==ostatni_dzielnik) continue;
            unikatowe_dzielniki[indeks_do_wymazania]=pierwsze[i];
            indeks_do_wymazania+=1;
            ostatni_dzielnik=pierwsze[i];
        }

        for(int i=0;i<99;i++){
            if(unikatowe_dzielniki[i]==0&&unikatowe_dzielniki[i+1]==0) break;
            wymaz_z_tablicy(pierwsze,unikatowe_dzielniki[i],ilosc_do_wymazania[i],100);
        }

        int liczba_podpierwiastkowa=1;
        int liczba_przedpierwiastkowa=1;
        for(int i=0;i<100;i++){
            if(pierwsze[i]!=0) {liczba_podpierwiastkowa*=pierwsze[i];}
            if(wylaczone_przed_pierwiastek[i]!=0) {liczba_przedpierwiastkowa*=wylaczone_przed_pierwiastek[i];}
        }

        SetConsoleTextAttribute(hConsole,15);
        cout << "\n\n  " << ((ze_znakiem==true) ? -liczba_przedpierwiastkowa : liczba_przedpierwiastkowa);
        if(liczba_podpierwiastkowa!=1) {
            cout << " pierwiastkow ";
            switch(stopien){
                case 2:
                cout << "kwadratowych";
                break;

                case 3:
                cout << "szesciennych";
                break;

                default:
                cout << stopien << ". stopnia";
            }
            cout << " z " << liczba_podpierwiastkowa;
        }
        SetConsoleTextAttribute(hConsole,7);
    } else {
        SetConsoleTextAttribute(hConsole,14);
        cout << "\n\n  Pierwiastek z podanej liczby o zadanym stopniu jest nieupraszczalny.\n";
        SetConsoleTextAttribute(hConsole,7);
    }
    if(ze_znakiem) {liczba*=(-1);}
    cout << "\n\n  Wartosc przyblizona podanego pierwiastka: " << setprecision(10) << pierwiastkowanie(stopien,liczba,10);
    cout << "\n\n";
    } while(0==0);
}