private List<string> autorzy = new List<string>();
        private string opis;
        private List<ParameterDesc> potrzebne;
        public Class1()
        {
            autorzy.Add("Paweł Budzyna");
            autorzy.Add("Łukasz Starostka");
            autorzy.Add("Szymon Okruta");
            opis = "Jest to metoda najszybszego spadku wielu zmiennych gradientowa";
            ro = 0.0001;
            zatrzymanaIteracja = 0;

            //     private int liczbaIteracji;
            //private string obrazfunkcji;
            //private List<string> tabzmiennych;
            //private List<double> tabwartosci;

            potrzebne = new List<ParameterDesc>();

            ParameterDesc cos = new ParameterDesc();
            cos.Name = "IterationLimit";
            cos.DescriptiveName = "Enter the number of iterations";
            cos.Type = InputType.Integer;
            potrzebne.Add(cos);

            cos = new ParameterDesc();
            cos.Name = "Formula";
            cos.DescriptiveName = "Enter the function";
            cos.Type = InputType.Text;
            potrzebne.Add(cos);


            cos = new ParameterDesc();
            cos.Name = "VariableNames";
            cos.DescriptiveName = "Give the names of variables, eg x";
            cos.Type = InputType.Text;
            potrzebne.Add(cos);

            cos = new ParameterDesc();
            cos.Name = "PointStart";
            cos.DescriptiveName = "Enter a starting point";
            cos.Type = InputType.Text;
            potrzebne.Add(cos);


        }

        #region IPlugin Members

        public List<string> Authors
        {
            get
            {
                return autorzy;
            }
            set
            {

            }
        }

        public PluginCategory Category
        {
            get
            {
                return PluginCategory.Deterministic;
            }
            set
            {

            }
        }

        public string Description
        {
            get
            {
                return opis;
            }
            set
            {

            }
        }

        public bool IfReportProgress
        {
            get
            {
                return false;
            }
            set
            {

            }
        }

        public string Name
        {
            get
            {
                return "Najszybszego spadku";
            }
            set
            {

            }
        }

        public List<ParameterDesc> Parameters
        {
            get
            {
                return potrzebne;
            }
            set
            {

            }
        }



        public int ReportProgress()
        {
            throw new NotImplementedException();
        }



        public List<OutputItem> Run(List<ParameterItem> parameter)
        {
            Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.CreateSpecificCulture("en-en");





            List<OutputItem> wynik = new List<OutputItem>();


            //     private int liczbaIteracji;
        //private string obrazfunkcji;
        //private List<string> tabzmiennych;
        //private List<double> tabwartosci;

            foreach (ParameterItem x in parameter)
            {
                switch (x.Name)
                {
                    case "IterationLimit":
                        liczbaIteracji = (int)x.Value;
                        break;

                    case "Formula":
                        obrazfunkcji = (string)x.Value;
                        break;

                    case "VariableNames":
                        tabzmiennych = (List<string>)x.Value;
                        break;

                    case "PointStart":
                       string pomoc = (string)x.Value;
                       string[] pomoc1 = pomoc.Split(',');
                       for (int i = 0; i < pomoc1.Length; i++)
                       {
                           tabwartosci.Add(Convert.ToDouble(pomoc1[i]));
                       }
                        break;

                    default:
                        break;
                }
            }

            metodaspadku();


            foreach (double x in tabwartosci)
            {
                OutputItem pojedynczeWyniki = new OutputItem();
                pojedynczeWyniki.TypeOfOutput = OutputType.Text;
                pojedynczeWyniki.Data = x;
                wynik.Add(pojedynczeWyniki);
            }

            return wynik;
        }

        public OptimalizationType Type
        {
            get
            {
                return OptimalizationType.Multi;
            }
            set
            {

            }
        }

        public WorkState State
        {
            get
            {
                return work;

            }
            set
            {
                value = work;
            }
        }

        public ErrorType Stop()
        {
            work = WorkState.Stopped;
            return ErrorType.StoppedByUser;
        }
        private WorkState work;
        public void Pause()
        {
            if (WorkState.Run == work)
            {
                work = WorkState.Paused;
            }

        }

        #endregion

        //moja metoda do liczenia

        //to co potrzebuje
        private int liczbaIteracji;
        private string obrazfunkcji;
        private List<string> tabzmiennych;
        private List<double> tabwartosci;




        //reszta jest stała i liczy automatycznie
        private double ro;
        private List<double> gradient;
        private int zatrzymanaIteracja;
        private void metodaspadku()
        {

            for (int i = zatrzymanaIteracja; i < liczbaIteracji; i++)
            {
                gradient = new List<double>();

                //znajdowanie gradieny funkcji
                for (int j = 0; j < tabwartosci.Count; j++)
                {
                    tabwartosci[j] -= 2 * ro;
                    double odejmowanie2 = wartoscfunkcji();
                    tabwartosci[j] += ro;
                    double odejmowanie1 = wartoscfunkcji();
                    tabwartosci[j] += ro;
                    double dodawanie1 = wartoscfunkcji();
                    tabwartosci[j] += ro;
                    double dodawanie2 = wartoscfunkcji();
                    tabwartosci[j] -= ro;
                    gradient.Add(pierwszapochodna(odejmowanie1, odejmowanie2, dodawanie1, dodawanie2));

                }
                //kierunek spadku
                for (int j = 0; j < gradient.Count; j++)
                {
                    gradient[j] = (0 - gradient[j]);

                }

                //szukanie lambdy czyli zmiennej w kierunku poszukiwań
                //pierwsze znalezienie funkji dodatkowej
                string nowyobrazfunkcji = obrazfunkcji;
                int licznik = 0;
                foreach (string x in tabzmiennych)
                {
                    string pomoc = " ( " + tabwartosci[licznik].ToString() + " + " + "x * " + gradient[licznik].ToString() + " ) ";
                    nowyobrazfunkcji = nowyobrazfunkcji.Replace(x, pomoc);
                    licznik++;
                }

                //obraz funkcji do znalezienia minumum
                //znalezienie lambda

                string obrazdodawanie = nowyobrazfunkcji.Replace("x", " ( x + " + ro.ToString() + " ) ");
                string obrazodejmowanie = nowyobrazfunkcji.Replace("x", " ( x - " + ro.ToString() + " ) ");

                string obrazdominimalizacji = "(( " + obrazdodawanie + " )-( " + obrazodejmowanie + ") ) / (2 * " + ro + " )";


                Regex liczbaprzecinek = new Regex(@"-?[0-9]*,[0-9]*E?[+||-]?[0-9]?[0-9]?");
                MatchCollection liczby = liczbaprzecinek.Matches(obrazdominimalizacji);
                HashSet<string> liczbypoprzecinku = new HashSet<string>();
                foreach (Match x in liczby)
                {
                    liczbypoprzecinku.Add(x.ToString());
                }

                Hashtable h = new Hashtable();
                StringBuilder zmienne = new StringBuilder();
                foreach (string x in liczbypoprzecinku)
                {
                    zmienne.Append("a");
                    obrazdominimalizacji = obrazdominimalizacji.Replace(" " + x + " ", zmienne.ToString());
                    h.Add(zmienne.ToString(), x);

                }
                h.Add("x", "0");

                double lambda = metodasiecznych(obrazdominimalizacji, h, true);

                //obliczam zmienną minimalną i mam zrobioną pierwszą pętle
                //czyli obliczamy nowy optymalny punkt
                licznik = 0;
                foreach (string x in tabzmiennych)
                {
                    tabwartosci[licznik] = (tabwartosci[licznik] + lambda * gradient[licznik]);
                    licznik++;


                }

                zatrzymanaIteracja++;
                //sprawdzić czy jest stop albo pause
                if (work == WorkState.Stopped || work == WorkState.Paused)
                {
                    //zapamiętać parametry

                    while (true)
                    {

                    }
                }
            }


        }



        private double pierwszapochodna(double odejmowanie2, double odejmowanie1, double dodawanie1, double dodawanie2)
        {
            double wynik = (odejmowanie2 - 8 * odejmowanie1 + 8 * dodawanie1 - dodawanie2) / (12 * ro);
            return wynik;
        }
        private double wartoscfunkcji()
        {
            double wynik = 0;

            ExpressionParser parser = new ExpressionParser();
            Hashtable h = new Hashtable();
            h.Add("pi", "3.14");
            h.Add("Pi", "3.14");
            int licznik = 0;
            foreach (string x in tabzmiennych)
            {
                h.Add(x, tabwartosci[licznik].ToString());
                licznik++;
            }


            // Parse and write the result
            wynik = parser.Parse(obrazfunkcji, h);

            return wynik;


        }


        private double metodasiecznych(string wygladfunkcji, Hashtable h, bool druga)
        {
            double wynik = 0;
            //dla własnej wiedzy nie potrzebne w algorytmie
            int iteracje = 0;

            double dokladnosc = 0.01;
            //przedział
            double x1 = -10000000;
            double x2 = 10000000;
            double pochodnax1 = pierwszapochodnadlasiecznych(wygladfunkcji, h, x1);
            double pochodnax2 = pierwszapochodnadlasiecznych(wygladfunkcji, h, x2);


            double xnowe = ((pochodnax1 * x2) - (pochodnax2 * x1)) / (pochodnax1 - pochodnax2);

            double pochodnanowe = pierwszapochodnadlasiecznych(wygladfunkcji, h, xnowe);
            bool zmienna = false;
            while (Math.Abs(pochodnanowe) > dokladnosc)
            {

                if ((pochodnanowe * pochodnax2) < 0)
                {
                    x1 = xnowe;
                    pochodnax1 = pochodnanowe;
                }
                else
                {
                    x2 = xnowe;
                    pochodnax2 = pochodnanowe;
                }

                iteracje++;

                pochodnax1 = pierwszapochodnadlasiecznych(wygladfunkcji, h, x1);
                pochodnax2 = pierwszapochodnadlasiecznych(wygladfunkcji, h, x2);

                xnowe = ((pochodnax1 * x2) - (pochodnax2 * x1)) / (pochodnax1 - pochodnax2);
                pochodnanowe = pierwszapochodnadlasiecznych(wygladfunkcji, h, xnowe);

                if (iteracje > 200)
                {
                    break;
                }


            }


            //xnowe wynik
            wynik = xnowe;
            return wynik;
        }
        private double wartoscfunkcjidlasiecznych(string obraz, Hashtable h, double x)
        {
            double wynik = 0;

            ExpressionParser parser = new ExpressionParser();
            h["x"] = x.ToString();


            // Parse and write the result
            wynik = parser.Parse(obraz, h);

            return wynik;


        }
        private double pierwszapochodnadlasiecznych(string obraz, Hashtable h, double x)
        {
            double wynik = (wartoscfunkcjidlasiecznych(obraz, h, x - 2 * ro) - 8 * wartoscfunkcjidlasiecznych(obraz, h, x - ro) + 2 * wartoscfunkcjidlasiecznych(obraz, h, x + ro) - wartoscfunkcjidlasiecznych(obraz, h, x + 2 * ro)) / (12 * ro);
            return wynik;
        }