public void TestInteg()
        {
            Vectors ce = Vectors.Random(dim, -5, 9);
            Vectors de = Vectors.Random(dim, -5, 5);

            Func <double> FF = () =>
            {
                Functional f1 = (Point y) => {
                    double sum = U(y);
                    for (int i = 0; i < dim; i++)
                    {
                        sum -= ce[i] * alpha(y, i) + de[i] * beta(y, i);
                    }
                    return(sum * sum);
                };
                Functional f2 = (Point y) => {
                    double sum = Unu(y);
                    for (int i = 0; i < dim; i++)
                    {
                        sum -= ce[i] * alphanu(y, i) + de[i] * betanu(y, i);
                    }
                    return(sum * sum);
                };

                return(IntegralClass.IntegralCurve((Point p) => f1(p) + f2(p), CIRCLE - 1));
            };

            $"Погрешность представления 1){FF()} 2){F(Vectors.Union2(ce,de))}".Show();
        }
        private Tuple <Vectors, double, double> HalfSolve(int len)
        {
            SqMatrix iD1 = D1.SubMatrix(len), iD2 = D2.SubMatrix(len), iS = S.SubMatrix(len);
            Vectors  iR1 = R1.SubVector(len), iR2 = R2.SubVector(len);

            SqMatrix iD1m = D1m.SubMatrix(len), iD2m = D2m.SubMatrix(len), idl;
            Vectors  idr;

            idl = (D2 - S * (D1m * S)).SubMatrix(len);
            idr = (R2 + S * D1m * R1).SubVector(len);

            Vectors id = idl.Solve(idr), icnew = (D1m * (R1 + S * id)).SubVector(len);

            Vectors res = Vectors.Union2(icnew, id);

            double p1 = IntegralClass.IntegralCurve((Point y) => (TestFuncAndCurve.Grads[GF - 1](y) * TestFuncAndCurve.Norm[CIRCLE - 1](y)).Sqr(), CIRCLE - 1);
            double p2 = IntegralClass.IntegralCurve((Point y) => (U(y)).Sqr(), CIRCLE - 1);

            Functional fif = (Point x) =>
            {
                double s = 0;
                for (int i = 0; i < id.Deg; i++)
                {
                    s += icnew[i] * alpha(x, i) + id[i] * beta(x, i);
                }
                return(Math.Abs(s - KursMethods.U(x)));
            };
            double L = IntegralClass.Integral(fif, CIRCLE - 1);

            $"len = {len}, L = {this.F(res)}".Show();

            return(new Tuple <Vectors, double, double>(res, F(res), L));
        }
        public void BeeDown(double min, double max, int count, int t, int maxmax = 100)
        {
            Vectors old = Vectors.Union2(cnew.SubVector(t), d.SubVector(t));

            //slau.GaussSelection(t);
            //cnew=

            var r = BeeHiveAlgorithm.GetGlobalMin(this.F, (t) * 2, min, max, 1e-15, count, 60, old, maxmax);

            //$"Hive method ---> {r.Item2}".Show();
            VecToCD(r.Item1);

            ErrorsMasL[t - 1] = r.Item2;
            Functional ff = (Point x) =>
            {
                double s = 0;
                for (int i = 0; i < t; i++)
                {
                    s += cnew[i] * alpha(x, i) + d[i] * beta(x, i);
                }
                return(Math.Abs(s - KursMethods.U(x)));
            };

            ErrorsMasQ[t - 1] = IntegralClass.Integral(ff, CIRCLE - 1);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Вычисление криволинейного интеграла первого рода по этой кривой от функции BasisFuncPow(int i,int j,Point z)
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public double Firstkind(int i, int j)
        {
            //return this.Firstkind((Point x)=>KursMethods.BasisFuncPow(i,j,(Point)x));
            Functional            f    = (Point x) => KursMethods.BasisFuncPow(i, j, (Point)x);
            Func <double, double> func = (double t) => f(this.Transfer(t));

            return(IntegralClass.Integral(func, this.a, this.b));
        }
Ejemplo n.º 5
0
        public void UltraHybrid(int t)
        {
            //UltraCount.Show();
            if (UltraCount == 0)//если вообще не решалось
            {
                //"Вошло".Show();
                x[0]            = b[0] / A[0, 0]; //x[0].Show();
                VALUE_FOR_ULTRA = Error(1);
                ErrorsMas[0]    = VALUE_FOR_ULTRA;
                Functional f = (Point x) =>
                {
                    double sum = this.x[0] * KursMethods.masPoints[0].PotentialF((Point)x);
                    double s   = sum - KursMethods.fig(x);
                    return(s * s);
                };
                Functional fM1 = (Point x) =>
                {
                    //это я ещё не использовал!!!
                    //Functional M1ApproxD = (Point u) =>
                    //{
                    //    Functional ro = (Point y) =>
                    //    {
                    //        double sss = this.x[0] * KursMethods.masPoints[0].PotentialF(u);
                    //        return sss * KursMethods.Exy(u, y);
                    //    };
                    //    return DoubleIntegral(ro, curve, curve.S, FuncMethods.DefInteg.Method.GaussKronrod15, 0.001, FuncMethods.DefInteg.countY) /*IntegralClass.Integral(ro, KursMethods.CIRCLE - 1)*/ /*- right(x)*/;
                    //};

                    double su = KursMethods.M1Approx(x);
                    double s  = su - KursMethods.TestFuncAndCurve.DFunctions[KursMethods.GF - 1](x);
                    return(s * s);
                };

                ErrorMasP[0] = Math.Sqrt(DoubleIntegral(f, curve, curve.S, FuncMethods.DefInteg.Method.GaussKronrod15, 0.001, FuncMethods.DefInteg.countY));
                ErrorsM1[0]  = Math.Sqrt(IntegralClass.Integral2(fM1, KursMethods.CIRCLE - 1));
                $"{1} = {ErrorsM1[0]}".Show();

                UltraCount++;
                for (int i = UltraCount + 1; i <= t; i++)
                {
                    UltraHybridLast(i);
                }
                UltraCount = t;
            }
            else if (UltraCount == t - 1)//если надо решить только по последней координате
            {
                UltraHybridLast(t);
                UltraCount++;
            }
            else
            {
                for (int i = UltraCount + 1; i <= t; i++)
                {
                    UltraHybridLast(i);
                }
                UltraCount = t;
            }
        }
        public void UltraHybrid(int t)
        {
            Functional f = (Point x) =>
            {
                double sum = 0;
                for (int i = 0; i < dim; i++)
                {
                    sum += c[i] * alpha(x, i) + d[i] * beta(x, i);
                }
                return(Math.Abs(sum - KursMethods.U(x)));
            };

            if (UltraCount == 0)//если вообще не решалось
            {
                ErrorsMasQ = new double[dim];
                ErrorsMasL = new double[dim];

                //"Вошло".Show();
                d[0]            = dr[0] / dl[0, 0]; //x[0].Show();
                VALUE_FOR_ULTRA = Error;
                ErrorsMasL[0]   = VALUE_FOR_ULTRA;
                ErrorsMasQ[0]   = IntegralClass.Integral(f, CIRCLE - 1);
                //BeeDown(-20, 20, 1000, 1);

                UltraCount++;
                for (int i = UltraCount + 1; i <= t; i++)
                {
                    UltraHybridLast(i);
                }
                UltraCount = t;
            }
            else if (UltraCount == t - 1)//если надо решить только по последней координате
            {
                UltraHybridLast(t);
                UltraCount++;
            }
            else
            {
                for (int i = UltraCount + 1; i <= t; i++)
                {
                    UltraHybridLast(i);
                }
                UltraCount = t;
            }
        }
        public static Tuple <double[], double[], int[], Func <Point, double> > LastMethod2(int n, int g, int cu, SLAUpok SYSTEM = null, SLAUpok SYSTEMQ = null)
        {
            ForDesigion.Building(n, g, cu, SYSTEM, SYSTEMQ);
            double[] ErrorsMasL = new double[n], ErrorsMasQ = new double[n];
            int[]    Times      = new int[n];

            var tmp = new BiharmonicEquation();

            double range = 200;

            Vectors old = Vectors.Union2(tmp.cnew, tmp.d);

            var r = BeeHiveAlgorithm.GetGlobalMin(tmp.F, 2 * n, -range, range, 1e-15, 1200, 60, old, -1);

            for (int t = 0; t < n; t++)
            {
                Functional fif = (Point x) =>
                {
                    double s = 0;
                    for (int i = 0; i < t; i++)
                    {
                        s += tmp.cnew[i] * alpha(x, i) + tmp.d[i] * beta(x, i);
                    }
                    return(Math.Abs(s - KursMethods.U(x)));
                };

                ErrorsMasQ[t] = IntegralClass.Integral(fif, CIRCLE - 1);
                ErrorsMasL[t] = tmp.F(Vectors.Union2(tmp.cnew.SubVector(t), tmp.d.SubVector(t)));
            }


            Func <Point, double> ff = (Point x) =>
            {
                double s = 0;
                for (int i = 0; i < tmp.dim; i++)
                {
                    s += tmp.cnew[i] * alpha(x, i) + tmp.d[i] * beta(x, i);
                }
                return(s);
            };

            return(new Tuple <double[], double[], int[], Func <Point, double> >(ErrorsMasL, ErrorsMasQ, Times, ff));
        }
        /// <summary>
        /// Созадть систему матриц и векторов по базисным функция
        /// </summary>
        /// <param name="n">Число базисных функций. Если -1, то берутся все функции</param>
        public BiharmonicEquation(int n = -1)
        {
            if (n == -1)
            {
                n = masPoints.Length;
            }
            D1 = new SqMatrix(n);
            D2 = new SqMatrix(n);
            S  = new SqMatrix(n);
            R1 = new Vectors(n);
            R2 = new Vectors(n);

            Parallel.For(0, n, (int i) =>
            {
                for (int j = i; j < n; j++)
                {
                    D1[i, j] = IntegralClass.IntegralCurve((Point x) => alpha(x, i) * alpha(x, j) + alphanu(x, i) * alphanu(x, j), CIRCLE - 1);
                    D2[i, j] = IntegralClass.IntegralCurve((Point x) => beta(x, i) * beta(x, j) + betanu(x, i) * betanu(x, j), CIRCLE - 1);
                    S[i, j]  = IntegralClass.IntegralCurve((Point x) => alpha(x, i) * beta(x, j) + alphanu(x, i) * betanu(x, j), CIRCLE - 1);
                }
                R1[i] = IntegralClass.IntegralCurve((Point y) => alphanu(y, i) * Unu(y) + alpha(y, i) * U(y), CIRCLE - 1);
                R2[i] = IntegralClass.IntegralCurve((Point y) => betanu(y, i) * Unu(y) + beta(y, i) * U(y), CIRCLE - 1);

                for (int j = i + 1; j < n; j++)
                {
                    D1[j, i] = D1[i, j];
                    D2[j, i] = D2[i, j];
                    S[j, i]  = S[i, j];
                }
            });


            d    = new Vectors(n);
            cnew = new Vectors(n);

            ErrorsMasL = new double[n];
            ErrorsMasQ = new double[n];

            p1 = IntegralClass.IntegralCurve((Point y) => Unu(y).Sqr(), CIRCLE - 1);
            p2 = IntegralClass.IntegralCurve((Point y) => U(y).Sqr(), CIRCLE - 1);

            $"p1 = {p1}, p2 = {p2}".Show();

            var mems = new Memoize <Point, Vectors[]>((Point p) => {
                Vectors[] r = new Vectors[4];
                for (int i = 0; i < 4; i++)
                {
                    r[i] = new Vectors(dim);
                }
                for (int i = 0; i < dim; i++)
                {
                    r[0][i] = alpha(p, i);
                    r[1][i] = alphanu(p, i);
                    r[2][i] = beta(p, i);
                    r[3][i] = betanu(p, i);
                }
                return(r);
            }).Value;
            Func <Point, Vectors[]> AB = (Point p) => mems(p);

            Func <Vectors, double> FF = (Vectors v) =>
            {
                Vectors ce = new Vectors(this.dim);
                Vectors de = new Vectors(this.dim);
                for (int i = 0; i < v.Deg / 2; i++)
                {
                    ce[i] = v[i];
                    de[i] = v[i + v.Deg / 2];
                }

                Functional func = (Point p) => {
                    var vec = AB(p);
                    return((U(p) - ce * vec[0] - de * vec[2]).Sqr() + (Unu(p) - ce * vec[2] - de * vec[3]).Sqr());
                };
                return(IntegralClass.IntegralCurve(func, CIRCLE - 1));

                Functional f1 = (Point y) => {
                    double sum = U(y);
                    for (int i = 0; i < dim; i++)
                    {
                        sum -= ce[i] * alpha(y, i) + de[i] * beta(y, i);
                    }
                    return(sum * sum);
                };
                Functional f2 = (Point y) => {
                    double sum = Unu(y);
                    for (int i = 0; i < dim; i++)
                    {
                        sum -= ce[i] * alphanu(y, i) + de[i] * betanu(y, i);
                    }
                    return(sum * sum);
                };

                return(IntegralClass.IntegralCurve((Point p) => f1(p) + f2(p), CIRCLE - 1));
            };

            F = (Vectors v) =>
            {
                return(FF(v));

                Vectors cc = new Vectors(this.dim);
                Vectors dd = new Vectors(this.dim);
                for (int i = 0; i < v.Deg / 2; i++)
                {
                    cc[i] = v[i];
                    dd[i] = v[i + v.Deg / 2];
                }

                int    k   = this.dim;
                double sum = p1 + p2 - 2 * (cc * R1 + dd * R2);
                for (int i = 0; i < k; i++)
                {
                    for (int j = 0; j < k; j++)
                    {
                        sum += 2 * cc[i] * dd[j] * S[i, j] + cc[i] * cc[j] * D1[i, j] + dd[i] * dd[j] * D2[i, j];
                    }
                }

                return(sum);
            };


            Vectors tmp = Vectors.Union2(new Vectors(dim), Vectors.Random(dim, -4, 4));

            $"Error! {FF(tmp)} != {F(tmp)}".Show();


            //        Parallel.Invoke(
            //() => D1m = D1.Invertion,
            //() => D2m = D2.Invertion
            //);

            //        dl = D2 - S * (D1m * S);
            //        dr = R2 + S * D1m * R1;
            //        slau = new SLAU(dl, dr);
        }
        /// <summary>
        /// Ультра-гибридный метод суперского решения по последней координате
        /// </summary>
        /// <param name="t"></param>
        public void UltraHybridLast(int t) //гибридный с координатной минимизацией по последней координате
        {
            double[] c = new double[t], cn = new double[t];
            //cnew = this.c.dup;

            for (int i = 0; i < t - 1; i++)
            {
                c[i]  = slau.x[i];
                cn[i] = cnew[i];
            }

            Vectors mk1 = new Vectors(c), mk2 = new Vectors(c);

            double sum = 0;

            slau.GaussSpeedy(t);
            cnew = this.c.dup;

            double tmp = Error;

            if (VALUE_FOR_ULTRA < tmp) //если погрешность выросла - исправить это, потому что новое решение не годится
            {
                $"{VALUE_FOR_ULTRA} < {tmp} при t = {t} (до покоординатной минимизации результата СПИДГАУССА)".Show();
                //покоординатная минимизация результата СПИДГАУССА
                MINIMAKA(t);

                tmp = Error;
                if (VALUE_FOR_ULTRA < tmp)
                {
                    $"{VALUE_FOR_ULTRA} < {tmp} при t = {t} (до полной покоординатной минимизации вектора с1 с2 ... 0)".Show();
                    for (int i = 0; i < t; i++)//исправили, теперь пробуем новый метод
                    {
                        slau.x[i] = c[i];
                        cnew[i]   = cn[i];
                    }

                    //покоординатная минимизация
                    MINIMAKA(t);


                    double tmp1 = Error;
                    if (VALUE_FOR_ULTRA < tmp1) //погрешность опять выросла - тогда просто оставляем 0 на конце
                    {
                        $"{VALUE_FOR_ULTRA} < {tmp1} при t = {t} (до полной покоординатной минимизации на конце)".Show();
                        for (int i = 0; i < t; i++)//исправили, теперь пробуем новый метод
                        {
                            slau.x[i] = c[i];
                            cnew[i]   = cn[i];
                        }

                        for (int j = 0; j < t - 1; j++)
                        {
                            sum += c[j] * S[t - 1, j];
                            sum += d[j] * D2[t - 1, j];
                        }
                        sum          += c[t - 1] * S[t - 1, t - 1];
                        slau.x[t - 1] = (R2[t - 1] - sum) / slau.A[t - 1, t - 1];
                        sum           = 0;

                        tmp = Error;
                        if (VALUE_FOR_ULTRA < tmp)
                        {
                            for (int i = 0; i < t - 1; i++)//исправили, теперь пробуем новый метод
                            {
                                slau.x[i] = c[i];
                                cnew[i]   = cn[i];
                            }
                            slau.x[t - 1] = 0;
                            cnew[t - 1]   = 0;
                        }
                        else
                        {
                            $"Погрешность уменьшена МИНИМАКОЙ НА КОНЦЕ на {(VALUE_FOR_ULTRA - tmp) / VALUE_FOR_ULTRA * 100} %".Show();
                            VALUE_FOR_ULTRA = tmp;
                        }
                    }
                    else
                    {
                        $"Погрешность уменьшена ПОЛНОЙ МИНИМАКОЙ на {(VALUE_FOR_ULTRA - tmp1) / VALUE_FOR_ULTRA * 100} %".Show();
                        VALUE_FOR_ULTRA = tmp1;
                    }
                }
                else
                {
                    $"Погрешность уменьшена МИНИМАКОЙ СПИДГАУССА на {(VALUE_FOR_ULTRA - tmp) / VALUE_FOR_ULTRA * 100} %".Show();
                    VALUE_FOR_ULTRA = tmp;
                }
            }
            else
            {
                $"Погрешность уменьшена СПИДГАУССОМ на {(VALUE_FOR_ULTRA - tmp) / VALUE_FOR_ULTRA * 100} %".Show();
                VALUE_FOR_ULTRA = tmp;
            }

            ErrorsMasL[t - 1] = VALUE_FOR_ULTRA;
            Functional f = (Point x) =>
            {
                double s = 0;
                for (int i = 0; i < t; i++)
                {
                    s += c[i] * alpha(x, i) + d[i] * beta(x, i);
                }
                return(Math.Abs(s - KursMethods.U(x)));
            };

            ErrorsMasQ[t - 1] = IntegralClass.Integral(f, CIRCLE - 1);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Ультра-гибридный метод суперского решения по последней координате
        /// </summary>
        /// <param name="t"></param>
        public void UltraHybridLast(int t) //гибридный с координатной минимизацией по последней координате
        {
            double[] c = new double[t];
            for (int i = 0; i < t - 1; i++)
            {
                c[i] = x[i];
            }
            Vectors mk1 = new Vectors(c), mk2 = new Vectors(c);
            bool    existres = true;

            double sum = 0;

            GaussSpeedy(t);

            double tmp = Error(t);

            if (VALUE_FOR_ULTRA < tmp) //если погрешность выросла - исправить это, потому что новое решение не годится
            {
                $"{VALUE_FOR_ULTRA} < {tmp} при t = {t} (до покоординатной минимизации результата СПИДГАУССА)".Show();
                //покоординатная минимизация результата СПИДГАУССА
                for (int k = 0; k <= t - 1; k++)
                {
                    for (int j = 0; j < k; j++)
                    {
                        sum += x[j] * A[k, j];
                    }
                    for (int j = k + 1; j < t - 1; j++)
                    {
                        sum += x[j] * A[k, j];
                    }
                    x[k] = (b[k] - sum) / A[k, k];
                    sum  = 0;
                }

                tmp = Error(t);
                if (VALUE_FOR_ULTRA < tmp)
                {
                    $"{VALUE_FOR_ULTRA} < {tmp} при t = {t} (до полно покоординатной минимизации вектора с1 с2 ... 0)".Show();
                    for (int i = 0; i < t; i++)//исправили, теперь пробуем новый метод
                    {
                        x[i] = c[i];
                    }

                    //покоординатная минимизация
                    for (int k = 0; k <= t - 1; k++)
                    {
                        for (int j = 0; j < k; j++)
                        {
                            sum += x[j] * A[k, j];
                        }
                        for (int j = k + 1; j < t - 1; j++)
                        {
                            sum += x[j] * A[k, j];
                        }
                        x[k] = (b[k] - sum) / A[k, k];
                        sum  = 0;
                    }


                    double tmp1 = Error(t);
                    if (VALUE_FOR_ULTRA < tmp1) //погрешность опять выросла - тогда просто оставляем 0 на конце
                    {
                        $"{VALUE_FOR_ULTRA} < {tmp1} при t = {t} (до полной покоординатной минимизации на конце)".Show();
                        for (int i = 0; i < t; i++)//исправили, теперь пробуем новый метод
                        {
                            x[i] = c[i];
                        }
                        for (int j = 0; j < t - 1; j++)
                        {
                            sum += x[j] * A[t - 1, j];
                        }
                        x[t - 1] = (b[t - 1] - sum) / A[t - 1, t - 1];
                        sum      = 0;
                        tmp      = Error(t);
                        if (VALUE_FOR_ULTRA < tmp)
                        {
                            for (int i = 0; i < t - 1; i++)
                            {
                                x[i] = c[i];
                            }
                            x[t - 1] = 0;
                            existres = false;
                        }
                        else
                        {
                            $"Погрешность уменьшена МИНИМАКОЙ НА КОНЦЕ на {(VALUE_FOR_ULTRA - tmp) / VALUE_FOR_ULTRA * 100} % (now {tmp})".Show();
                            VALUE_FOR_ULTRA = tmp;
                        }
                    }
                    else
                    {
                        $"Погрешность уменьшена ПОЛНОЙ МИНИМАКОЙ на {(VALUE_FOR_ULTRA - tmp1) / VALUE_FOR_ULTRA * 100}% (now {tmp1})".Show();
                        VALUE_FOR_ULTRA = tmp1;
                    }
                }
                else
                {
                    $"Погрешность уменьшена МИНИМАКОЙ СПИДГАУССА на {(VALUE_FOR_ULTRA - tmp) / VALUE_FOR_ULTRA * 100} % (now {tmp})".Show();
                    VALUE_FOR_ULTRA = tmp;
                }
            }
            else
            {
                $"Погрешность уменьшена СПИДГАУССОМ на {(VALUE_FOR_ULTRA - tmp) / VALUE_FOR_ULTRA * 100} % (now {tmp})".Show();
                VALUE_FOR_ULTRA = tmp;
            }

            ErrorsMas[t - 1] = VALUE_FOR_ULTRA;
            Functional f = (Point x) =>
            {
                sum = 0;

                for (int ii = 1; ii <= t; ii++)
                {
                    sum += this.x[ii - 1] * KursMethods.masPoints[ii - 1].PotentialF(x);
                }
                double s = sum - KursMethods.fig(x);
                return(s * s);
            };

            ErrorMasP[t - 1] = Math.Sqrt(DoubleIntegral(f, curve, curve.S, FuncMethods.DefInteg.Method.GaussKronrod15, 0.001, FuncMethods.DefInteg.countY));
            //UltraCount = t;
            NEVA = Nev(A, x, b, t);

            Functional fM1 = (Point x) =>
            {
                //    Functional M1ApproxD = (Point u) =>
                //{
                //    Functional ro = (Point y) =>
                //    {
                //        double sss = 0; for (int i = 0; i < t; i++) sss += this.x[i] * KursMethods.masPoints[i].PotentialF(u);
                //        return sss * KursMethods.Exy(u, y);
                //    };
                //    //return DoubleIntegral(ro, curve, curve.S, FuncMethods.DefInteg.Method.GaussKronrod15, 0.001, FuncMethods.DefInteg.countY) /*IntegralClass.Integral(ro, KursMethods.CIRCLE - 1)*/ /*- right(x)*/;
                //    return IntegralClass.Integral(ro, KursMethods.CIRCLE - 1);
                //};

                double su = KursMethods.M1Approx(x);
                double s  = su - KursMethods.U(x);
                return(s * s);
            };

            if (existres)
            {
                $"Считается погрешность метода 1".Show();
                ErrorsM1[t - 1] = Math.Sqrt(IntegralClass.Integral2(fM1, KursMethods.CIRCLE - 1));
            }
            else
            {
                ErrorsM1[t - 1] = ErrorsM1[t - 2];
            }


            $"{t} = {ErrorsM1[t - 1]}".Show();
        }