none
Не могу исправить ошибку для аппроксимации данных(точек)

    Вопрос

  • Такая проблема. Написана программа для интерполяции данных (точек) трех методов: Ньютон, линейная и квадратичная интерполяция. В результате добавления новой точки в коллекцию, наследуемые классы игнорируют эту точку и аппрооксимируют только дефолтному забитые точки.

                       

     public partial class Form1: Form 
        { 
            private List <Point> Points = new List <Point> {}; 
            Приближение ap = new Approximation (); 
            private List <Point> ApproximatedPointsN = новый список <Point> {};      
            private List <Point> ApproximatedPointsL = новый список <Point> {}; 
            private List <Point> ApproximatedPointsQ = новый список <Point> {}; 
            private Lineinaya ln = new Lineinaya (); 

            public Form1 () 
            { 
                InitializeComponent (); 
                ap.InitialValues ​​(); 
                Points = ap.GetPoints; 
                Список (); 
                Newton nw = new Newton ();



            { 
                listBox1.Items.Clear (); 
                foreach (точка p в точках) 
                { 
                    listBox1.Items.Add (p.ToString ()); 
                } 
            } 

            private void button2_Click (отправитель объекта, EventArgs e) 
            { 
                chart1.ChartAreas.Clear (); 
                chart1.Series.Clear (); 

                ChartArea chartArea1 = новый ChartArea (); 
                chart1.ChartAreas.Add (chartArea1); 

                chartArea1.CursorX.IsUserEnabled = true; 
                chartArea1.CursorX.IsUserSelectionEnabled = true; 
                chartArea1.AxisX.ScaleView.Zoomable = true;
                chartArea1.AxisY.ScrollBar.IsPositionedInside = true; 

                chartArea1.CursorY.IsUserEnabled = true; 
                chartArea1.CursorY.IsUserSelectionEnabled = true; 
                chartArea1.AxisY.ScaleView.Zoomable = true; 
                chartArea1.AxisY.ScrollBar.IsPositionedInside = true; 

                Серия series1 = новая серия 
                { 
                    ChartType = SeriesChartType.Point, 
                    Color = Color.Blue, 
                    MarkerSize = 10, 
                    MarkerStyle = MarkerStyle.Circle, 
                    Name = "Точки" 
                }; 
                foreach (точка p в точках) 
                {
                    series1.Points.AddXY (pX, pY); 
                } 
                chart1.Series.Add (series1); 

                if (comboBox1.SelectedIndex == 0 || comboBox2.SelectedIndex == 0) 
                { 
                    Серия series3 = новая серия 
                    { 
                        ChartType = SeriesChartType.Spline, 
                        Color = Color.Black, 
                        MarkerSize = 5, 
                        Name = "Линейная интерполяция" 
                    }; 

                    ApproximatedPointsL = ln.FillApproximatedPointsLineinay (); 
                    foreach (точка p в ApproximatedPointsL) 
                    { 
                        series3.Points.AddXY (pX, pY);
                    } 
                    chart1.Series.Add (серия 3); 
                } 

                if (comboBox1.SelectedIndex == 1 || comboBox2.SelectedIndex == 1) 
                { 
                    Серия series4 = новая серия 
                    { 
                        ChartType = SeriesChartType.Spline, 
                        Color = Color.Aquamarine, 
                        MarkerSize = 5, 
                        Name = "Квадратичная интерполяция" 
                    }; 
                    Квадратичный qd = новый квадратичный (); 
                    ApproximatedPointsQ = qd.FillApproximatedPointsQuadratic (); 
                    foreach (точка p в ApproximatedPointsQ) 
                    {
                        series4.Points.AddXY (pX, pY); 
                    } 
                    chart1.Series.Add (серия 4); 
                } 

                if (comboBox1.SelectedIndex == 2 || comboBox2.SelectedIndex == 2) 
                { 
                    Серия series2 = новая серия 
                    { 
                        ChartType = SeriesChartType.Spline, 
                        Color = Color.Red, 
                        MarkerSize = 5, 
                        Name = "Интерполяция методом Ньютона" 
                    }; 
                    Newton nw = new Newton (); 
                    ApproximatedPointsN = nw.FillApproximatedPointsNewton (); 
                    foreach (точка p в ApproximatedPointsN)
                    { 
                        series2.Points.AddXY (pX, pY); 
                    } 
                    chart1.Series.Add (серия 2); 
                } 

            } 


            private void button1_Click (отправитель объекта, EventArgs e) 
            { 
                int x = int.Parse (textBox1.Text); 
                int y = int.Parse (textBox2.Text); 
                ap.AddPoint (x, y); 
                textBox1.Clear (); 
                textBox2.Clear (); 
                Список (); 
            } 

            public void Удалить () 
            { 
                if (listBox1.SelectedIndex == 0 || listBox1.SelectedIndex == Points.Count - 1) 
                {
                    ap.Points.RemoveAt (listBox1.SelectedIndex); 
                    Список (); 
                } 

                else MessageBox.Show («Метод Ньютона используется только для равноотстоящих узлов интерполяции.»); 
            } 

            private void button3_Click (отправитель объекта, EventArgs e) 
            { 
                Удалить (); 
            } 
        }

    ---------------------------------------

    интерфейс IOperation 
        { 
            void AddPoint (int x, int y); 
            void InitialValues ​​(); 
        } 

        class Approximation: IOperation 
        {  
            public List <Point> Points = new List <Point> {}; 

            public Approcimation () 
            { 
                InitialValues ​​(); 
            } 

            public List <Point> GetPoints {get {return Points; }} 

            public void AddPoint (int a, int b) 
            { 
                Points.Add (новая точка (a, b)); 
            } 

            public void InitialValues ​​() 
            { 
                AddPoint (100, 200); 
                AddPoint (110, 224); 
                AddPoint (120, 235);
                AddPoint (130, 265); 
                AddPoint (140, 198); 
                AddPoint (150, 290); 
                AddPoint (160, 200); 
                AddPoint (170, 456); 
                AddPoint (180, 180); 
                AddPoint (190, 100); 
                AddPoint (200, 240); 
            } 
        }

    --------------------------------------

    class Newton: Approcsimation 
        { 
            private List <Point> ApproximatedPointsNewton {get; задавать; 
            private double H {get {return Math.Abs ​​(Points [0] .X - Points [1] .X); }} 
            public int N {get {return Points.Count; }} 

            public Newton () 
            { 
                Approximation ap = new Approximation (); 
            } 

            private double GetQ (double x) 
            {           
                double q = (x - Points [0] .X) / H; 
                return q; 
            } 

            private double FinalDifference (int index, int differenceOrder) 
            {  
                double delta = 0; 
                if (differenceOrder> = 1)
                { 
                    if (differenceOrder! = 1) 
                        delta = FinalDifference (index + 1, differenceOrder - 1) - FinalDifference (index, differenceOrder - 1); 
                    if (differenceOrder == 1) 
                    { 
                        delta = Points [index + 1] .Y - Points [index] .Y; 
                    } 
                    return delta; 
                } 
                return delta; 
            } 

            private int Factorial (int number) 
            { 
                int fact = 1; 
                если (число> 0) 
                { 
                    для (int i = 1; i <число; i ++) 
                        факт * = i; 
                }
                факт возвращения; 
            } 

            private double Coefficient (double x, int count) 
            { 
                double factor = 1; 
                if (count! = 0) 
                    для (int i = 1; i <count; i ++) 
                    { 
                        коэффициент * = GetQ (x) - (i - 1); 
                    } 
                else коэффициент = GetQ (x); 
                коэффициент возврата; 
            } 

            public double MethodNewton (double x) 
            {            
                double Pn = Points [0] .Y; 
                для (int i = 0; i <N; i ++) 
                { 
                    Pn + = (Коэффициент (x, i + 1) * FinalDifference (0, i)) / Factorial (i + 1);
                } 
                return Pn; 
            } 

            public List <Point> FillApproximatedPointsNewton () 
            { 
                ApproximatedPointsNewton = новый список <Point> {}; 
                int a = Points [0] .X; 
                int b = Points.Last (). ИКС; 
                for (int i = a; i <= b; i ++) 
                { 
                    ApproximatedPointsNewton.Add (new Point (i, (int) MethodNewton (i))); 
                } 
                return ApproximatedPointsNewton; 
            } 

        }

    -------------------------------------------------- --------

    class Quadratic: Approcsimation 
        { 
            private List <Point> ApproximatedPointsQuadratic {get; задавать; 
            Приближение ap = new Approximation (); 

            private double FindA (double x0, double x1, double x2, double y0, double y1, double y2) 
            { 
                double A = 0; 
                A = ((y2 - y0) * (x1 - x0) - (y1 - y0) * (x2 - x0)) / (Math.Pow (x2, 2) - Math.Pow (x0, 2)) * (x1 - x0) - (Math.Pow (x1, 2) - Math.Pow (x0, 2)) * (x2 - x1); 
                return A; 
            } 

            private double FindB (double x0, double x1, double x2, double y0, double y1, double y2) 
            { 
                double B = 0; 
                double A = FindA (x0, x1, x2, y0, y1, y2);
                B = (y1 - y0 - A * (Math.Pow (x1, 2) - Math.Pow (x0, 2))) / (x1 - x0); 
                return B; 
            } 

            private double FindC (double x0, double x1, double x2, double y0, double y1, double y2) 
            { 
                double C = 0; 
                double A = FindA (x0, x1, x2, y0, y1, y2); 
                double B = FindB (x0, x1, x2, y0, y1, y2); 
                C = y0 - (A * Math.Pow (x0, 2) + B * x0); 
                return C; 
            } 

            public double MethodQuadratic (double x) 
            { 
                double Fx = 0; 
                for (int i = 1; i <Points.Count-1; i ++) 
                { 
                    if (x> = ap.Points [i-1] .X && x <= ap.Points [i] .X)
                    { 
                        Fx = FindA (Points [i-1] .X, Points [i] .X, Точки [i + 1] .X, Точки [i-1] .Y, Точки [i] .Y, Точки [i + 1] .Y) * Math.Pow (x, 2) + FindB (Точки [i - 1] .X, Points [i] .X, Points [i + 1] .X, Points [i - 1] .Y, Points [i] .Y, Points [i + 1] .Y) * x + FindC (Точки [i - 1] .X, Точки [i] .X, Точки [i + 1] .X, Точки [i - 1] .Y, Точки [i] .Y, Точки [i + 1] .Y ); 
                        return Fx; 
                    } 
                } 
                return -10; 
            } 

            public List <Point> FillApproximatedPointsQuadratic () 
            { 
                ApproximatedPointsQuadratic = новый список <Point> {}; 
                int a = Points [0] .X; 
                int b = Points.Last (). ИКС; 
                for (int i = a; i <= b; i ++)
                { 
                    ApproximatedPointsQuadratic.Add (новая точка (i, (int) MethodQuadratic (i))); 
                } 
                return ApproximatedPointsQuadratic; 
            } 
        }

    -------------------------------------------------- ---------------

    class Lineinaya: Approcsimation 
        { 
            private List <Point> ApproximatedPointsLineinaya {get; задавать; 
            Приближение ap = new Approximation (); 

            private double FindA (double x0, double x1, double y0, double y1) 
            { 
                double Ai = 0; 
                Ai = (y1 - y0) / (x1 - x0); 
                return Ai; 
            } 

            public Lineinaya () 
            { 
                Points = ap.GetPoints; 
            } 

            private double FindB (double x0, double x1, double y0, double y1) 
            { 
                double Bi = 0; 
                Bi = y0 - (FindA (x0, x1, y0, y1) * x0); 
                return Bi; 
            }

            public double MethodLineinaya (double x) 
            { 
                double Fx = 0; 
                for (int i = 0; i <ap.Points.Count; i ++) 
                { 
                    if (x> = Points [i] .X && x <= Points [i + 1] .X) 
                    { 
                        Fx = FindA (точки [i ] .X, Points [i + 1] .X, Points [i] .Y, Points [i + 1] .Y) * x + FindB (Points [i] .X, Points [i + 1] .X, Точки [i] .Y, Точки [i + 1] .Y); 
                        return Fx; 
                    }                
                } 
                return -10; 
            } 

            public List <Point> FillApproximatedPointsLineinay () 
            { 
                ApproximatedPointsLineinaya = новый список <Point> {};
                int a = Points [0] .X; 
                int b = Points.Last (). X; 
                for (int i = a; i <= b; i ++) 
                { 
                    ApproximatedPointsLineinaya.Add (новая точка (i, (int) MethodLineinaya (i))); 
                } 
                return ApproximatedPointsLineinaya; 
            } 
        }

    Вот такая вот программа

    12 июня 2018 г. 15:53

Все ответы