C# Vector.L2Norm方法代码示例

 public Constraint(double x, double y)
 {
     _vector = Vector<double>.Build.DenseOfArray(new[] { x, y });
     X = x;
     Y = y;
     Length = _vector.L2Norm();
     UnitVector = _vector.Divide(Length);
 }

        /// <summary>
        /// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
        /// solution vector and x is the unknown vector.
        /// </summary>
        /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
        /// <param name="input">The solution vector, <c>b</c></param>
        /// <param name="result">The result vector, <c>x</c></param>
        public void Solve(Matrix matrix, Vector input, Vector result)
        {
            // If we were stopped before, we are no longer
            // We're doing this at the start of the method to ensure
            // that we can use these fields immediately.
            _hasBeenStopped = false;

            // Error checks
            if (matrix == null)
            {
                throw new ArgumentNullException("matrix");
            }

            if (matrix.RowCount != matrix.ColumnCount)
            {
                throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix");
            }

            if (input == null)
            {
                throw new ArgumentNullException("input");
            }

            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            if (result.Count != input.Count)
            {
                throw new ArgumentException(Resources.ArgumentVectorsSameLength);
            }

            if (input.Count != matrix.RowCount)
            {
                throw Matrix.DimensionsDontMatch<ArgumentException>(input, matrix);
            }

            // Initialize the solver fields
            // Set the convergence monitor
            if (_iterator == null)
            {
                _iterator = Iterator.CreateDefault();
            }

            if (_preconditioner == null)
            {
                _preconditioner = new UnitPreconditioner();
            }

            _preconditioner.Initialize(matrix);

            var d = new DenseVector(input.Count);
            var r = DenseVector.OfVector(input);

            var uodd = new DenseVector(input.Count);
            var ueven = new DenseVector(input.Count);

            var v = new DenseVector(input.Count);
            var pseudoResiduals = DenseVector.OfVector(input);

            var x = new DenseVector(input.Count);
            var yodd = new DenseVector(input.Count);
            var yeven = DenseVector.OfVector(input);

            // Temp vectors
            var temp = new DenseVector(input.Count);
            var temp1 = new DenseVector(input.Count);
            var temp2 = new DenseVector(input.Count);

            // Define the scalars
            Complex32 alpha = 0;
            Complex32 eta = 0;
            float theta = 0;

            // Initialize
            var tau = input.L2Norm().Real;
            Complex32 rho = tau*tau;

            // Calculate the initial values for v
            // M temp = yEven
            _preconditioner.Approximate(yeven, temp);

            // v = A temp
            matrix.Multiply(temp, v);

            // Set uOdd
            v.CopyTo(ueven);

            // Start the iteration
            var iterationNumber = 0;
            while (ShouldContinue(iterationNumber, result, input, pseudoResiduals))
            {
//.........这里部分代码省略.........

        public static Vector<double> FindCVect(Vector<double> aVect, Vector<double> bVect, double alpha, double beta, double C)
        {
            aVect /= aVect.L2Norm();
            bVect /= bVect.L2Norm();
            alpha *= Math.PI / 180.0;
            beta *= Math.PI / 180.0;

            Vector<double> planeNormal = Calculator.CrossProduct(aVect, bVect);
            planeNormal /= planeNormal.L2Norm();
            double theta = Math.Acos(planeNormal[2]);
            double phi = Math.Atan2(planeNormal[1], planeNormal[0]);

            Matrix<double> Rz = DenseMatrix.OfArray(new double[,] { { Math.Cos(phi), Math.Sin(phi), 0},
                                                                    {-Math.Sin(phi), Math.Cos(phi), 0},
                                                                    {     0,             0,         1} });
            Matrix<double> Ry = DenseMatrix.OfArray(new double[,] { { Math.Cos(theta), 0, -Math.Sin(theta)},
                                                                    {     0,           1,       0         },
                                                                     {Math.Sin(theta), 0,  Math.Cos(theta)} });

            aVect = Ry * Rz * aVect;
            bVect = Ry * Rz * bVect;

            double cx1 = (Math.Cos(beta) * bVect[1] - Math.Cos(alpha) * aVect[1]);
            double cx2 = (aVect[0] * bVect[1] - bVect[0] * aVect[1]);

            double cx = cx1 / cx2;
            double cy = (Math.Cos(beta) * bVect[0] - Math.Cos(alpha) * aVect[0]) / (aVect[1] * bVect[0] - bVect[1] * aVect[0]);

            Vector<double> cVect = DenseVector.OfArray(new double[] { cx, cy, Math.Sqrt(1 - cx * cx - cy * cy) });
            cVect = C * Rz.Inverse() * Ry.Inverse() * cVect;

            return cVect;
        }