/// <summary>
        /// Решает всё как надо, выдаёт массив погрешностей для границы (минимизируемый функционал) и вообще по области (цель решения задачи)
        /// </summary>
        /// <param name="n"></param>
        /// <param name="g"></param>
        /// <param name="cu"></param>
        /// <param name="SYSTEM"></param>
        /// <param name="SYSTEMQ"></param>
        /// <returns></returns>
        public static Tuple <double[], double[]> CreateAndSolve(int n, int g, int cu, SLAUpok SYSTEM = null, SLAUpok SYSTEMQ = null)
        {
            //"вход".Show();
            ForDesigion.Building(n, g, cu, SYSTEM, SYSTEMQ);
            //"есть билд".Show();

            var tmp = new BiharmonicEquation();

            tmp.NevaskShow();

            tmp.UltraHybrid(tmp.dim);

            tmp.BeeDown(-20, 20, 1000, tmp.dim - 1);

            return(new Tuple <double[], double[]>(tmp.ErrorsMasL, tmp.ErrorsMasQ));
        }
        public static Tuple <double[], double[], int[], Func <Point, double> > LastMethod(int n, int g, int cu, SLAUpok SYSTEM = null, SLAUpok SYSTEMQ = null, int maxmax = 150)
        {
            double[] ErrorsMasL = new double[n], ErrorsMasQ = new double[n];
            int[]    Times      = new int[n];
            bool Follow(int len, int it)
            {
                var d = ErrorsMasL.Where(nn => nn > 0).ToArray();

                return(d.Length - d.Distinct().Count() <= len);
            }

            var tmp = new BiharmonicEquation(); //tmp.NevaskShow();

            for (int t = 1; t <= n; t++)
            {
                $"Now t = {t}".Show();
                double range = 20 + 2 * (n - t);

                DateTime time = DateTime.Now;
                if (Follow(5, t))
                {
                    //if (t==n)
                    //{
                    //    var s = tmp.HalfSolve(t);
                    //    if (s.Item2 < ErrorsMasL[t - 2])
                    //    {
                    //        ErrorsMasL[t - 1] = s.Item2;
                    //        ErrorsMasQ[t - 1] = s.Item3;

                    //        for (int i = 0; i < s.Item1.Deg / 2; i++)
                    //        {
                    //            tmp.cnew[i] = s.Item1[i];
                    //            tmp.d[i] = s.Item1[i + s.Item1.Deg / 2];
                    //        }
                    //        continue;
                    //    }
                    //}

                    tmp.BeeDown(-range, range, 300 + 10 * t, t, maxmax);
                    Times[t - 1]      = (DateTime.Now - time).Milliseconds + ((t == 1) ? 0 : Times[t - 2]);
                    ErrorsMasL[t - 1] = tmp.ErrorsMasL[t - 1];
                    ErrorsMasQ[t - 1] = tmp.ErrorsMasQ[t - 1];
                }
                else
                {
                    Times[t - 1]          = Times[t - 2];
                    ErrorsMasL[t - 1]     = ErrorsMasL[t - 2];
                    ErrorsMasQ[t - 1]     = ErrorsMasQ[t - 2];
                    tmp.ErrorsMasL[t - 1] = ErrorsMasL[t - 1];
                    tmp.ErrorsMasQ[t - 1] = ErrorsMasQ[t - 1];
                }
            }

            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));
        }