/// <summary>
 /// Сумма элементов матрицы
 /// </summary>
 /// <param name="matrix">Матрица</param>
 /// <returns>Сумма элементов</returns>
 public static long Sum(IMatrix<int> matrix)
 {
     long sum = 0;
     foreach (IIndex index in MultiDimensionMatrixEnumerator.Indexes(matrix))
         sum += matrix[index];
     return sum;
 }

    public void EhCrossPRESS(int[]group, IMatrix XX, IMatrix YY, IMatrix XU, IMatrix YU)
    {
      IVector meanX,scaleX,meanY,scaleY;
      if(_predictedY==null || _predictedY.Rows!=YU.Rows || _predictedY.Columns!=YU.Columns)
        _predictedY = new MatrixMath.BEMatrix(YU.Rows,YU.Columns);

      MultivariateRegression.PreprocessForAnalysis(_preprocessOptions,_spectralRegions, XX, YY, out meanX, out scaleX, out meanY, out scaleY);
      _analysis.AnalyzeFromPreprocessed(XX,YY,_numFactors);
      _numFactors = Math.Min(_numFactors,_analysis.NumberOfFactors);
   
      MultivariateRegression.PreprocessSpectraForPrediction(_preprocessOptions,XU,meanX,scaleX);


      // allocate the crossPRESS vector here, since now we know about the number of factors a bit more
      if(null==_crossPRESS)
        _crossPRESS = new double[_numFactors+1]; // one more since we want to have the value at factors=0 (i.e. the variance of the y-matrix)

      // for all factors do now a prediction of the remaining spectra
      _crossPRESS[0] += MatrixMath.SumOfSquares(YU);
      for(int nFactor=1;nFactor<=_numFactors;nFactor++)
      {
        _analysis.PredictYFromPreprocessed(XU,nFactor,_predictedY);
        MultivariateRegression.PostprocessY(_predictedY,meanY,scaleY);
        _crossPRESS[nFactor] += MatrixMath.SumOfSquaredDifferences(YU,_predictedY);
      }
    }

        /// <summary>
        ///  Ensures a minimum number of self loops exist in the matrix by adding values to the diagonal.
        /// </summary>
        public static void EnsureMinSelfLoopCount(IMatrix<double> network, int n)
        {
            int ctr = 0;

            // find all non-zeros on diagonal
            for (int i = 0; i < network.NodeCount; i++)
            {
                if (network[i,i]!=0.0)
                    ctr++;
            }

            // if that many self loops exist, return
            if (ctr >= n)
                return;

            // else create the needed number of self loops
            int needed = n;
            if (n < ctr)
                needed = ctr - n;

            ctr = 0;  // re-use ctr variable
            do
            {
                for (int i = 0; i < network.NodeCount; i++)
                {
                    network[i, i] = network[i, i] + 1.0;
                    ctr++;
                    if (ctr >= needed)
                        break;
                }
            } while (needed >ctr);
        }

 public RecordValue(IMatrix matr1, IMatrix matr2, IDrawer dr1, IDrawer dr2)
 {
     this.matr1 = matr1;
       this.matr2 = matr2;
       this.dr1 = dr1;
       this.dr2 = dr2;
 }

		public void RemoveMatrixRow(IMatrix matrix, IDBDataSource dBDataSource, int row)
		{
			dBDataSource.RemoveRecord(row - 1);

			// Loads the user interface with current data from the matrix objects data source.
			matrix.LoadFromDataSource();
		}

 public void Border(IMatrix m)
 {
     if (matrComp.col_num == matrComp.col_num - 1 && matrComp.row_num == matrComp.row_num - 1)
     {
       drawer.Border(this);
     }
 }

        /// <summary>
        /// Средняя нагрузка при заданных параметрах разбиения матрицы
        /// </summary>
        /// <param name="matrix">Матрица</param>
        /// <param name="partitioning">Параметры разбиения матрицы</param>
        /// <returns>Сумма элементов</returns>
        public static double W(IMatrix<int> matrix, params int[] partitioning)
        {
            int N = 1;
            for (int i = 0; i < partitioning.Length; i++)
                N *= partitioning[i];

            return Sum(matrix) / (double)N;
        }

        public void CellValue(IMatrix m, int row, int col)
        {
            if (row == r || col == c) { }
                   else {

                drawer.CellValue(this, row, col);
            }
        }

		public void SetTransform (LinearGradientBrush widget, IMatrix transform)
		{
			var brush = ((BrushObject)widget.ControlObject);
			brush.Matrix = transform;
			var newmatrix = brush.InitialMatrix.Clone ();
			newmatrix.Multiply (transform.ToSD ());
			brush.Brush.Transform = newmatrix;
		}

 public void Inititialize()
 {
     _container = new Mock<IContainer>();
     _container.Setup(x => x.GetInstance<IPrimeNumber>()).Returns(new PrimeNumber());
     _primeNumber = _container.Object.GetInstance<IPrimeNumber>();
     _container.Setup(x => x.GetInstance<IMatrix>()).Returns(new Matrix(_primeNumber));
     _matrix = _container.Object.GetInstance<IMatrix>();
 }

		/// <summary>Write a matrix of floats to a StreamWriter object</summary>
		/// <param name="writer">a <see cref="StreamWriter"/></param>
		/// <param name="matrix">the matrix of floats to write out</param>
		static public void WriteMatrix(this TextWriter writer, IMatrix<float> matrix)
		{
			writer.WriteLine(matrix.NumberOfRows + " " + matrix.NumberOfColumns);
			for (int i = 0; i < matrix.NumberOfRows; i++)
				for (int j = 0; j < matrix.NumberOfColumns; j++)
					writer.WriteLine(i + " " + j + " " + matrix[i, j].ToString(CultureInfo.InvariantCulture));
			writer.WriteLine();
		}

 public SolutionVisualizerForm(SplittedMatrix splittedMatrix, IMatrix<int> matrix, ISolution solution, int min, int max, double criterion)
 {
     InitParameters(splittedMatrix, matrix, solution);
     SetSizeOfBitmap();
     SetMinMax(min, max);
     SetBoundOfValuesOfMatrix(min, max);
     SetCriterion(criterion);
     settingsEvent();
 }

        public void ReadFromFile(out IMatrix A, out Vector b, out Vector x_init)
        {
            //          Не хватает проверки path
            using (System.IO.StreamReader file = new System.IO.StreamReader(path))
            {
                var st = file.ReadToEnd().Replace('.',',').Split(new char[] { '\n', ' ', '\t', '\r' },
                StringSplitOptions.RemoveEmptyEntries);
                int n, m;
                if (!int.TryParse(st[0], out n))
                    throw new Exception("Bad file format");
                n = int.Parse(st[0]);

                int[] ia = new int[n + 1];

                double[] d = new double[n];
                double[] rightPart = new double[n];
                double[] x0 = new double[n];
                long offset = 1;

                for (int i = 0; i < n + 1; i++, offset++)
                    ia[i] = int.Parse(st[offset]);
                m = ia[n] - 1;
                int[] ja = new int[m];
                double[] al = new double[m];
                double[] au = new double[m];
                for (int i = 0; i < m; i++, offset++)
                    ja[i] = int.Parse(st[offset]);
                if (ia[0] != 0)
                {
                    for (int i = 0; i < n + 1; i++)
                        ia[i]--;

                    for (int i = 0; i < m; i++)
                        ja[i]--;
                }

                for (int i = 0; i < m; i++,offset++)
                    al[i] = double.Parse(st[offset]);

                for (int i = 0; i < m; i++, offset++)
                    au[i] = double.Parse(st[offset]);

                for (int i = 0; i < n; i++,offset++)
                    d[i] = double.Parse(st[offset]);

                for (int i = 0; i <  n; i++,offset++)
                    rightPart[i] = double.Parse(st[offset]);

                for (int i = 0; i < n; i++, offset++)
                    x0[i] = double.Parse(st[offset]);

                A = new RowColumnSparseMatrix(n, ia, ja, al, au, d);
                b = new Vector(rightPart);
                x_init = new Vector(x0);
            }
        }

 public override void CellValue(IMatrix m, int row, int col)
 {
     string s = m[row, col].ToString();
     Font font = new Font("Arial",12);
     SolidBrush brush = new SolidBrush(Color.CornflowerBlue);
     RectangleF rect = new RectangleF(x + h*col, y +h*row, h , h);
     StringFormat format = new StringFormat();
     format.Alignment = StringAlignment.Center;
     g.DrawString(s,font,brush,rect,format);
 }

        public Matrix(IMatrix x)
        {
            m = x.ColumnDimension;
            n = x.RowDimension;
            el = new double[n, m];

            for (int row = 0; row < n; row++)
                for (int column = 0; column < m; column++)
                    el[row, column] = x[row, column];

        }

		public static bool Equals(IMatrix m, float xx, float yx, float xy, float yy, float x0, float y0)
		{
			var e = m.Elements;
			return
				FloatEquals(e[0], xx) &&
				FloatEquals(e[1], yx) &&
				FloatEquals(e[2], xy) &&
				FloatEquals(e[3], yy) &&
				FloatEquals(e[4], x0) &&
				FloatEquals(e[5], y0);
		}

		void Push (IMatrix matrix)
		{
			// If we're in a SaveTransform block,
			// increment the pop count.
			current = current ?? NewEntry ();
			current.Matrices.Add (matrix);

			current.PopCount++;
			
			// push the transform
			push (matrix);
		}

		public void SaveTransform()
		{
			if (stack == null)
				stack = new Stack<IMatrix>();

			if (Current != null)
			{
				stack.Push(Current);
				Current = Current.Clone();
			}
			else
				stack.Push(null);
		}

		void Prepend(IMatrix matrix)
		{
			if (Current != null)
			{
				pop();
				Current.Prepend(matrix);
			}
			else
			{
				Current = matrix.Clone();
			}
			push(Current);
		}

        private void InitParameters(IMatrix<int> matrix)
        {
            Name = "MatrixVisualizerForm";
            Text = "     Visualizer of matrix";
            this.matrix = matrix;
            coefficient = 255.0 / CoreUtilities.Utilities.Max(matrix);
            sizeOfMatrix = new Size(matrix.Size(1), matrix.Size(0));
            matrixBitmap = new Bitmap(sizeOfMatrix.Width, sizeOfMatrix.Height);
            modeOfDrawing = Mode.Matrix;

            settingsEvent = SetStep;
            settingsEvent += SetCriterionSettings;
            settingsEvent += SetZoom;
            settingsEvent += SetBitmap;
        }