示例#1
0
文件: Form1.cs 项目: a-27m/vssdb
        //private Complex Newtone(DoubleOfVectorFunction[] Fns,
        //    Complex z0, double eps, out int iterations)
        //{  //a:=eval(diff(f,x),[x=x0,y=y0]);b:=eval(diff(f,y),[x=x0,y=y0]);d:=eval(f,[x=x0,y=y0]);k(x,y):=a*(x-x0)+b*(y-y0)+d
        //    double x = z0.re;
        //    double y = z0.im;
        //    double x0, y0;
        //    DoubleOfVectorFunction F = Fns[0];
        //    DoubleOfVectorFunction G = Fns[1];
        //    iterations = 0;

        //    do
        //    {
        //        x0 = x;
        //        y0 = y;

        //        #region eval {F, G, dFx, dFy, dGx, dGy} @ (x0,y0)
        //        double F0 = F(x0, y0);
        //        double G0 = G(x0, y0);
        //        double dFx0 = dFx(F, x0, y0);
        //        double dFy0 = dFy(F, x0, y0);
        //        double dGx0 = dFx(G, x0, y0);
        //        double dGy0 = dFy(G, x0, y0);
        //        double t = -dGx0 * dFy0 + dFx0 * dGy0;

        //        if (t == 0)
        //            return Complex.NaN;
        //        if (double.IsNaN(t))
        //            return Complex.NaN;

        //        #endregion

        //        x = (G0 * dFy0 - dGy0 * F0) / t + x0;
        //        y = (dGx0 * F0 - dFx0 * G0) / t + y0;

        //        if (++iterations % 200 == 0)
        //            return Complex.NaN;

        //    } while (Math.Sqrt((x - x0) * (x - x0) + (y - y0) * (y - y0)) >= eps);

        //    return new Complex(x, y);
        //}

        private Complex Newtone(DoubleOfVectorFunction[] Fns,
                                Complex z0, double eps, out int iterations)
        {   //a:=eval(diff(f,x),[x=x0,y=y0]);
            //b:=eval(diff(f,y),[x=x0,y=y0]);
            //d:=eval(f,[x=x0,y=y0]);
            //k(x,y):=a*(x-x0)+b*(y-y0)+d
            double x = z0.re;
            double y = z0.im;
            double x0, y0;
            DoubleOfVectorFunction F = Fns[0];
            DoubleOfVectorFunction G = Fns[1];

            iterations = 0;

            do
            {
                x0 = x;
                y0 = y;

                #region eval {F, G, dFx, dFy, dGx, dGy} @ (x0,y0)

                double F0   = f1(x0, y0);
                double G0   = f2(x0, y0);
                double dFx0 = df1x(x0, y0);
                double dFy0 = df1y(x0, y0);
                double dGx0 = df2x(x0, y0);
                double dGy0 = df2y(x0, y0);

                double t = -dGx0 * dFy0 + dFx0 * dGy0;

                if (t == 0)
                {
                    return(Complex.NaN);
                }
                if (double.IsNaN(t))
                {
                    return(Complex.NaN);
                }

                #endregion

                x = (G0 * dFy0 - dGy0 * F0) / t + x0;
                y = (dGx0 * F0 - dFx0 * G0) / t + y0;

                if (++iterations % 200 == 0)
                {
                    return(Complex.NaN);
                }
            } while (Math.Abs(x - x0) >= eps || Math.Abs(y - y0) >= eps);
            //} while (Math.Sqrt((x - x0) * (x - x0) + (y - y0) * (y - y0)) >= eps);

            return(new Complex(x, y));
        }
示例#2
0
文件: Form1.cs 项目: a-27m/vssdb
        private void FindRoot()
        {
            Complex res = Complex.NaN;

            #region prepare dform
            if (dForm == null)
            {
                dForm               = new DekartForm(100, 100, 300, 300);
                dForm.ClientSize    = new Size(600, 600);
                dForm.Use_IsVisible = false;
                dForm.FormClosed   += new FormClosedEventHandler(delegate(object s, FormClosedEventArgs eva)
                {
                    dForm = null;
                });
            }
            else
            {
                dForm.RemoveAllGraphics();
            }

            #endregion

            List <Root>   roots  = new List <Root>();
            List <PointF> pts    = new List <PointF>();
            List <Color>  colors = new List <Color>();

            Color[] baseColors = new Color[] {
                Color.Red,
                Color.Orange,
                Color.Yellow,
                Color.Green,
                Color.LightBlue,
                Color.Blue,
                Color.Violet
            };

            double y1 = x1, y2 = x2;

            DoubleOfVectorFunction[] dovf = new DoubleOfVectorFunction[] { f1, f2 };
            Complex c = new Complex(0);

            for (double y = y1; y < y2; y += hy)
            {
                for (double x = x1; x < x2; x += hx)
                {
                    int   iterations;
                    float percent;
                    c.re = x;
                    c.im = y;
                    res  = Newtone(dovf, c, eps, out iterations);

                    bool inRange = true;
                    inRange &= res.re > x1;
                    inRange &= res.re < x2;
                    inRange &= res.im > y1;
                    inRange &= res.im < y2;


                    if (Complex.IsNaN(res) || !inRange)
                    {
                        colors.Add(Color.Black);
                        pts.Add(new PointF((float)x, (float)y));
                    }
                    else
                    {
                        if (roots.Count == 0)
                        {
                            Root newRoot;
                            newRoot.color = baseColors[roots.Count % baseColors.Length];
                            newRoot.value = res;
                            roots.Add(newRoot);
                        }

                        percent = iterations / 15f;
                        if (percent > 1f)
                        {
                            percent = 1f;
                        }

                        bool needAdd = true;
                        foreach (Root r in roots)
                        {
                            if (Near(r.value, res))
                            {
                                colors.Add(ColorModifer.Brightness(r.color, percent));
                                pts.Add(new PointF((float)x, (float)y));

                                needAdd = false;
                                break;
                            }
                        }

                        if (needAdd)
                        {
                            Root newRoot;
                            newRoot.color = baseColors[roots.Count % baseColors.Length];
                            newRoot.value = res;
                            roots.Add(newRoot);

                            colors.Add(ColorModifer.Brightness(newRoot.color, percent));
                            pts.Add(new PointF((float)x, (float)y));
                        }
                    }
                }
            }

            DotGraphic dotGraphic = new DotGraphic(pts.ToArray(), colors.ToArray());
            dotGraphic.CurrentColorSchema = new MathGraphic.ColorSchema(
                Color.Black, Color.DimGray, Color.DimGray, Color.Gray);
            dForm.AddGraphic(dotGraphic);

            MathGraphic mg;
            mg = new MathGraphic(Color.White, DrawModes.DrawLines, f1x, f1y,
                                 -5f, 5f, 0.01f);
            dForm.AddGraphic(mg);

            mg = new MathGraphic(Color.White, DrawModes.DrawLines, f2x, f2y,
                                 -5f, 5f, 0.01f);
            dForm.AddGraphic(mg);

            dForm.Show();
            dForm.Update2();

            foreach (Root z in roots)
            {
                listRoots.Items.Add("z" + (listRoots.Items.Count + 1) + " = "
                                    + z.value.ToString("F6"));
                listY.Items.Add("f,g" + (listY.Items.Count + 1) + " = "
                                + f1(z.value.re, z.value.im).ToString("F6") + ", "
                                + f2(z.value.re, z.value.im).ToString("F6"));
            }
        }
示例#3
0
文件: Form1.cs 项目: a-27m/vssdb
 double dFy(DoubleOfVectorFunction f, params double[] z)
 {
     return((f(z[0], z[1] + h) - f(z[0], z[1] - h)) / 2 / h);
 }
示例#4
0
文件: Form1.cs 项目: a-27m/vssdb
 double dFx(DoubleOfVectorFunction f, params double[] z)
 {
     return((f(z[0] + h, z[1]) - f(z[0] - h, z[1])) / 2 / h);
 }