c# 线性代数 克·施密特（Gram Schmidt）

        Gram-Schmidt 方法是一种用于将线性无关的向量集合转化为一组正交（垂直）的向量集合的数学技术。这个方法是在线性代数中常用的一种技术，用于处理向量空间中的正交化和标准化操作。Gram-Schmidt 方法的主要思想是，通过一系列的投影和减法操作，将原始向量集合转化为一个正交化的向量集合。

在 C# 中，Gram-Schmidt 方法可以通过以下步骤实现：

1. 对于给定的向量集合，首先将每个向量进行标准化，即将每个向量除以其模长，使其成为单位向量。
2. 从第一个向量开始，依次处理每个向量。对于每个后续的向量，都进行投影操作，将其投影到前面已经处理过的向量上并将投影部分减去，以确保正交性。
3. 重复以上步骤直到处理完所有向量，最终得到一组正交化的向量集合。

        通过 Gram-Schmidt 方法的正交化过程，我们可以获得一组正交向量，这些向量在线性空间中相互垂直，可以更好地描述和分析向量集合的性质。

        在实际编程中，可以创建一个 Vector 类来表示向量，实现标准化、点积、投影等基本操作，并编写一个 GramSchmidt 方法来实现 Gram-Schmidt 正交化过程。这样就可以对给定的向量集合进行正交化处理，以便后续的线性代数运算和分析。

Gram-Schmidt 正交化方法的示例一：

using System;

class Program
{
    static void Main()
    {
        double[][] vectors = {
            new double[] {1, 1, 0},
            new double[] {1, -1, 0},
            new double[] {0, 0, 2}
        };

        double[][] orthogonalizedVectors = GramSchmidt(vectors);

        Console.WriteLine("Orthogonalized Vectors:");
        foreach (var vector in orthogonalizedVectors)
        {
            Console.WriteLine(string.Join(", ", vector));
        }
    }

    static double DotProduct(double[] v1, double[] v2)
    {
        double result = 0;
        for (int i = 0; i < v1.Length; i++)
        {
            result += v1[i] * v2[i];
        }
        return result;
    }

    static double[] Subtract(double[] v1, double[] v2)
    {
        double[] result = new double[v1.Length];
        for (int i = 0; i < v1.Length; i++)
        {
            result[i] = v1[i] - v2[i];
        }
        return result;
    }

    static double[] Normalize(double[] vector)
    {
        double magnitude = Math.Sqrt(DotProduct(vector, vector));
        double[] normalized = new double[vector.Length];
        for (int i = 0; i < vector.Length; i++)
        {
            normalized[i] = vector[i] / magnitude;
        }
        return normalized;
    }

    static double[][] GramSchmidt(double[][] vectors)
    {
        int n = vectors.Length;
        int m = vectors[0].Length;
        double[][] u = new double[n][];
        double[][] e = new double[n][];

        for (int i = 0; i < n; i++)
        {
            u[i] = new double[m];
            e[i] = new double[m];
            Array.Copy(vectors[i], u[i], m);
            for (int j = 0; j < i; j++)
            {
                double projection = DotProduct(vectors[i], e[j]);
                for (int k = 0; k < m; k++)
                {
                    u[i][k] -= projection * e[j][k];
                }
            }
            e[i] = Normalize(u[i]);
        }

        return e;
    }
}

Gram-Schmidt 正交化方法示例二：

using System;
using System.Collections.Generic;

class Vector
{
    public double[] Components { get; set; }

    public Vector(params double[] components)
    {
        Components = components;
    }

    public double Magnitude()
    {
        double sum = 0;
        foreach (var component in Components)
        {
            sum += Math.Pow(component, 2);
        }
        return Math.Sqrt(sum);
    }

    public Vector Normalize()
    {
        double magnitude = Magnitude();
        double[] normalizedComponents = new double[Components.Length];
        for (int i = 0; i < Components.Length; i++)
        {
            normalizedComponents[i] = Components[i] / magnitude;
        }
        return new Vector(normalizedComponents);
    }

    public static double DotProduct(Vector v1, Vector v2)
    {
        double result = 0;
        for (int i = 0; i < v1.Components.Length; i++)
        {
            result += v1.Components[i] * v2.Components[i];
        }
        return result;
    }

    public static Vector Subtract(Vector v1, Vector v2)
    {
        double[] resultComponents = new double[v1.Components.Length];
        for (int i = 0; i < v1.Components.Length; i++)
        {
            resultComponents[i] = v1.Components[i] - v2.Components[i];
        }
        return new Vector(resultComponents);
    }
}

class Program
{
    static void Main()
    {
        Vector[] vectors = {
            new Vector(1, 1, 0),
            new Vector(1, -1, 0),
            new Vector(0, 0, 2)
        };

        List<Vector> orthogonalizedVectors = new List<Vector>();
        
        foreach (var vector in vectors)
        {
            Vector orthogonalizedVector = vector;
            foreach (var existingVector in orthogonalizedVectors)
            {
                Vector projection = Vector.Normalize(existingVector) * Vector.DotProduct(vector, existingVector);
                orthogonalizedVector = Vector.Subtract(orthogonalizedVector, projection);
            }
            orthogonalizedVectors.Add(Vector.Normalize(orthogonalizedVector));
        }
        
        Console.WriteLine("Orthogonalized Vectors:");
        foreach (var vector in orthogonalizedVectors)
        {
            Console.WriteLine(string.Join(", ", vector.Components));
        }
    }
}

        在上面两个示例中，我们实现了 Gram-Schmidt 方法来将给定的向量集合进行正交化处理，并输出正交向量组。您可以根据需要对该代码进行修改和扩展。