C# Matrix.Copy方法代码示例

        /// <summary>
        /// Cholesky Factorization of a Matrix
        /// </summary>
        /// <param name="m">Input Matrix</param>
        /// <returns>Cholesky Faxtorization (R.T would be other matrix)</returns>
        public static Matrix Cholesky(Matrix m)
        {
            if (m.Rows != m.Cols)
                throw new InvalidOperationException("Factorization requires a symmetric positive semi-definite matrix!");

            int n = m.Rows;
            Matrix A = m.Copy();

            for (int k = 0; k < n; k++)
            {
                if (A[k, k] <= 0)
                    throw new SingularMatrixException("Matrix is not symmetric positive semi-definite!");

                A[k, k] = System.Math.Sqrt(A[k, k]);
                for (int j = k + 1; j < n; j++)
                    A[j, k] = A[j, k] / A[k, k];

                for (int j = k + 1; j < n; j++)
                    for (int i = j; i < n; i++)
                        A[i, j] = A[i, j] - A[i, k] * A[j, k];
            }

            // put back zeros...
            for (int i = 0; i < n; i++)
                for (int j = i + 1; j < n; j++)
                    A[i, j] = 0;

            return A;
        }

        /// <summary>Generate Logistic Regression model based on a set of examples.</summary>
        /// <param name="x">The Matrix to process.</param>
        /// <param name="y">The Vector to process.</param>
        /// <returns>Model.</returns>
        public override IModel Generate(Matrix x, Vector y)
        {
            // create initial theta
            Matrix copy = x.Copy();

            copy = PreProcessing.FeatureDimensions.IncreaseDimensions(copy, PolynomialFeatures);

            // add intercept term
            copy = copy.Insert(Vector.Ones(copy.Rows), 0, VectorType.Col);

            Vector theta = Vector.Ones(copy.Cols);

            var run = numl.Math.Optimization.GradientDescent.Run(theta, copy, y, this.MaxIterations, this.LearningRate, new numl.Math.Functions.Cost.LogisticCostFunction(), 
                this.Lambda, new numl.Math.Functions.Regularization.Regularization());

            LogisticRegressionModel model = new LogisticRegressionModel()
            {
                Descriptor = this.Descriptor,
                Theta = run.Item2,
                LogisticFunction = new Math.Functions.Logistic(),
                PolynomialFeatures = this.PolynomialFeatures
            };

            return model;
        }

		public Matrix Transform(Matrix m)
		{
			var cols = m.Columns;
			var rows = m.Rows;
			var res = m.Copy();
			var stepsLeft = steps;
			while (stepsLeft-- > 0)
			{
				for (var r = 0; r < rows; r++)
				{
					var tempIn = new double[cols + padding];
					for (var c = 0; c < cols; c++)
						tempIn[c] = res.MatrixData[r][c];
					var tempOut = TransformStep(tempIn, cols);
					for (var c = 0; c < cols; c++)
						res.MatrixData[r][c] = tempOut[c];
				}
				for (var c = 0; c < cols; c++)
				{
					var tempIn = new double[rows + padding];
					for (var r = 0; r < rows; r++)
						tempIn[r] = res.MatrixData[r][c];
					var tempOut = TransformStep(tempIn, rows);
					for (var r = 0; r < rows; r++)
						res.MatrixData[r][c] = tempOut[r];
				}
				cols /= 2;
				rows /= 2;
			}
			return res;
		}

        /// <summary>Generate Linear Regression model based on a set of examples.</summary>
        /// <param name="x">The Matrix to process.</param>
        /// <param name="y">The Vector to process.</param>
        /// <returns>Model.</returns>
        public override IModel Generate(Matrix x, Vector y)
        {
            // create initial theta
            Vector theta = Vector.Ones(x.Cols + 1);
            Matrix copy = x.Copy();

            // normalise features
            for (int i = 0; i < copy.Cols; i++)
            {
                var j = FeatureNormalizer.FeatureScale(copy[i, VectorType.Col]);
                for (int k = 0; k < copy.Rows; k++)
                {
                    copy[k, i] = j[k];
                }
            }

            // add intercept term
            copy = copy.Insert(Vector.Ones(copy.Rows), 0, VectorType.Col);

            // run gradient descent
            var run = GradientDescent.Run(theta, copy, y, MaxIterations, LearningRate, new LinearCostFunction(),
                Lambda, new Regularization());

            // once converged create model and apply theta

            LinearRegressionModel model = new LinearRegressionModel(x.Mean(VectorType.Row), x.StdDev(VectorType.Row))
            {
                Descriptor = Descriptor,
                Theta = run.Item2
            };

            return model;
        }

 public SimplexMethodDual(Matrix a, Matrix b, Matrix c, List<int> baseIndexes)
 {
     m_matrixA = a.Copy();
     m_matrixB = b.Copy();
     m_matrixC = c.Copy();
     m_baseIndexes = new List<int>(baseIndexes);
     m_baseIndexes.Sort();
 }

 public SimplexMethodDualModification(Matrix a, Matrix b, Matrix c, List<int> baseIndexes, Matrix dMin, Matrix dMax)
 {
     m_matrixA = a.Copy();
     m_matrixB = b.Copy();
     m_matrixC = c.Copy();
     m_baseIndexes = new List<int>(baseIndexes);
     m_baseIndexes.Sort();
     m_dMin = dMin.Copy();
     m_dMax = dMax.Copy();
 }

 public QuadraticProgrammingProblem(Matrix a, /*Matrix b, */Matrix c, Matrix d, Matrix x, IEnumerable<int> jBasis, IEnumerable<int> jStar)
 {
     _a = a.Copy();
     //_b = b.Copy();
     _c = c.Copy();
     _d = d.Copy();
     _x = x.Copy();
     _jBasis = new List<int>(jBasis);
     _jStar = new List<int>(jStar);
 }

 public SimplexMethodGeneralIteration(Matrix a,  Matrix b, Matrix c, Matrix xBase, List<int> baseIndexes)
 {
     m_matrixA = a.Copy();
     if (b != null)
     {
         m_matrixB = b.Copy();
     }
     m_matrixC = c.Copy();
     m_xBaseVector = xBase.Copy();
     m_baseIndexes = new List<int>(baseIndexes);
     m_baseIndexes.Sort();
 }

        /// <summary>Generates.</summary>
        /// <param name="matrix">The matrix.</param>
        public void Generate(Matrix matrix)
        {
            // generate centered matrix
            // (using a copy since centering is in place)
            this.X = matrix.Copy().Center(VectorType.Col);

            // compute eigen-decomposition
            // of covariance matrix
            var eigs = this.X.Covariance().Eigs();
            this.Eigenvalues = eigs.Item1;
            this.Eigenvectors = eigs.Item2;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            m_richTextBox.Text = "";
            var r = new Random();
            //var m1 = new Matrix(2, 2);
            //m1[0, 0] = 0; m1[0, 1] = 1;
            //m1[1, 0] = 1; m1[1, 1] = 0;
            //var m1 = new Matrix(3, 3);
            //m1[0, 0] = 0; m1[0, 1] = -2; m1[0, 2] = 4;
            //m1[1, 0] = 0; m1[1, 1] = -4; m1[1, 2] = -1;
            //m1[2, 0] = -4; m1[2, 1] = -3; m1[2, 2] = 3;
            //var m1 = new Matrix(5, 5);
            //m1[0, 0] = 2; m1[0, 1] = 1; m1[0, 2] = 4; m1[0, 3] = -3; m1[0, 4] = 0.000001;
            //m1[1, 0] = 1; m1[1, 1] = -1; m1[1, 2] = 2; m1[1, 3] = 2; m1[1, 4] = 1;
            //m1[2, 0] = 3; m1[2, 1] = 0; m1[2, 2] = 6; m1[2, 3] = -1; m1[2, 4] = 1;
            //m1[3, 0] = 1; m1[3, 1] = 1; m1[3, 2] = 1; m1[3, 3] = 1; m1[3, 4] = 1;
            //m1[4, 0] = 2; m1[4, 1] = 4; m1[4, 2] = -1; m1[4, 3] = 0; m1[4, 4] = 2;

            var m1 = new Matrix(4, 4);
            m1[0, 0] = 2; m1[0, 1] = 1; m1[0, 2] = 4; m1[0, 3] = 0;
            m1[1, 0] = 1; m1[1, 1] = -1; m1[1, 2] = 2; m1[1, 3] = 1.00001;
            m1[2, 0] = 3; m1[2, 1] = 0; m1[2, 2] = 6; m1[2, 3] = 1;
            m1[3, 0] = 1; m1[3, 1] = 1; m1[3, 2] = 1; m1[3, 3] = 0;

            //for (int i = 0; i < m1.RowsCount; i++)
            //{
            //    for (int j = 0; j < m1.ColumnsCount; j++)
            //    {
            //        m1[i, j] = r.Next(-5, 5);
            //    }
            //}

            m_richTextBox.Text += "A\n";
            m_richTextBox.Text += m1.ToString();

            Matrix minv;
            try
            {
                minv = m1.Copy().Invert();
            }
            catch (Exception exception)
            {
                MessageBox.Show(exception.Message);
                return;
            }

            m_richTextBox.Text += "B\n";
            m_richTextBox.Text += minv.ToString();
            m_richTextBox.Text += "AB=\n";
            m_richTextBox.Text += m1.Multiply(minv).ToString();
        }

 /// <summary>
 /// Adds a specified number of polynomial features to the training set Matrix.
 /// </summary>
 /// <param name="x">Training set</param>
 /// <param name="polynomialFeatures">Number of polynomial features to add</param>
 /// <returns></returns>
 public static Matrix IncreaseDimensions(Matrix x, int polynomialFeatures)
 {
     Matrix Xtemp = x.Copy();
     int maxCols = Xtemp.Cols;
     for (int j = 0; j < maxCols - 1; j++)
     {
         for (int k = 0; k <= polynomialFeatures; k++)
         {
             for (int m = 0; m <= k; m++)
             {
                 Vector v = (Xtemp[j, VectorType.Col].ToVector() ^ (double)(k - m)) * (Xtemp[j + 1, VectorType.Col] ^ (double)m).ToVector();
                 Xtemp = Xtemp.Insert(v, Xtemp.Cols - 1, VectorType.Col);
             }
         }
     }
     return Xtemp;
 }

        /// <summary>Cholesky Factorization of a Matrix.</summary>
        /// <exception cref="InvalidOperationException">Thrown when the requested operation is invalid.</exception>
        /// <exception cref="SingularMatrixException">Thrown when a Singular Matrix error condition occurs.</exception>
        /// <param name="m">Input Matrix.</param>
        /// <returns>Cholesky Faxtorization (R.T would be other matrix)</returns>
        public static Matrix Cholesky(Matrix m)
        {
            if (m.Rows != m.Cols)
            {
                throw new InvalidOperationException("Factorization requires a symmetric positive semi-definite matrix!");
            }

            var n = m.Rows;
            var A = m.Copy();

            for (var k = 0; k < n; k++)
            {
                if (A[k, k] <= 0)
                {
                    throw new SingularMatrixException("Matrix is not symmetric positive semi-definite!");
                }

                A[k, k] = Math.Sqrt(A[k, k]);
                for (var j = k + 1; j < n; j++)
                {
                    A[j, k] = A[j, k] / A[k, k];
                }

                for (var j = k + 1; j < n; j++)
                {
                    for (var i = j; i < n; i++)
                    {
                        A[i, j] = A[i, j] - A[i, k] * A[j, k];
                    }
                }
            }

            // put back zeros...
            for (var i = 0; i < n; i++)
            {
                for (var j = i + 1; j < n; j++)
                {
                    A[i, j] = 0;
                }
            }

            return A;
        }

        private Matrix EigenDecomp(Matrix M)
        {
            Matrix shift = MatrixFactory.IdentityMatrix(M.Height) * ComputeShift(M);
            QRDecomposition qr = (M - shift).QR();
            Matrix Eigenvector = qr.Q;

            for (int i = 0; i < Constants.ITERATION_DEPTH; i++) {
                M = qr.R * qr.Q + shift;
                shift = MatrixFactory.IdentityMatrix(M.Height) * ComputeShift(M);
                qr = (M - shift).QR();

                Eigenvector *= qr.Q;

                if (M.IsDiagonal()) {
                    break;
                }
            }
            D = M.Copy();
            return Eigenvector;
        }

        /// <summary>Generate Linear Regression model based on a set of examples.</summary>
        /// <param name="X">The Matrix to process.</param>
        /// <param name="y">The Vector to process.</param>
        /// <returns>Model.</returns>
        public override IModel Generate(Matrix X, Vector y)
        {
            this.Preprocess(X);

            // copy matrix
            Matrix copy = X.Copy();

            // add intercept term
            copy = copy.Insert(Vector.Ones(copy.Rows), 0, VectorType.Col);

            // create initial theta
            Vector theta = Vector.Rand(copy.Cols);

            // run gradient descent
            var optimizer = new numl.Math.Optimization.Optimizer(theta, this.MaxIterations, this.LearningRate)
            {
                CostFunction = new numl.Math.Functions.Cost.LinearCostFunction()
                {
                    X = copy,
                    Y = y,
                    Lambda = this.Lambda,
                    Regularizer = new numl.Math.Functions.Regularization.L2Regularizer()
                }
            };

            optimizer.Run();

            // once converged create model and apply theta

            LinearRegressionModel model = new LinearRegressionModel()
            {
                Descriptor = this.Descriptor,
                NormalizeFeatures = base.NormalizeFeatures,
                FeatureNormalizer = base.FeatureNormalizer,
                FeatureProperties = base.FeatureProperties,
                Theta = optimizer.Properties.Theta
            };

            return model;
        }

		public Matrix TransformBack(Matrix m)
		{
			var res = m.Copy();
			var sizes = new int[steps, 2];
			sizes[0, 0] = m.Rows;
			sizes[0, 1] = m.Columns;
			for (var i = 1; i < steps; i++)
			{
				sizes[i, 0] = sizes[i - 1, 0]/2;
				sizes[i, 1] = sizes[i - 1, 1]/2;
			}
			var stepsLeft = steps;
			while (stepsLeft-- > 0)
			{
				var rows = sizes[stepsLeft, 0];
				var cols = sizes[stepsLeft, 1];
				for (var c = 0; c < cols; c++)
				{
					var tempIn = new double[rows];
					for (var r = 0; r < rows; r++)
						tempIn[r] = res.MatrixData[r][c];
					var tempOut = TransformBackStep(tempIn);
					for (var r = 0; r < rows; r++)
						res.MatrixData[r][c] = tempOut[r];
				}
				for (var r = 0; r < rows; r++)
				{
					var tempIn = new double[cols];
					for (var c = 0; c < cols; c++)
						tempIn[c] = res.MatrixData[r][c];
					var tempOut = TransformBackStep(tempIn);
					for (var c = 0; c < cols; c++)
						res.MatrixData[r][c] = tempOut[c];
				}
			}
			return res;
		}