c++ 计算二维向量模长norm

在C++中，计算二维向量的模长（也称为长度或范数）通常使用欧几里得范数（Euclidean norm），它是由向量的两个分量的平方和开方得到的。对于一个二维向量( x, y )，其模长（||v||_2）的计算公式如下：

#include <cmath> // 引入数学库以使用sqrt函数

double vectorMagnitude(double x, double y) {
    return std::sqrt(x * x + y * y); // 使用sqrt计算平方和的平方根
}

在这个函数中，`x` 和 `y` 分别代表向量的x轴和y轴分量，`std::sqrt` 函数是从 `<cmath>` 库中获取的，用于计算平方根。

如果你想创建一个完整的类来表示二维向量并包含计算模长的方法，可以这样做：

class Vector2D {
public:
    Vector2D(double x, double y) : x_(x), y_(y) {}

    double magnitude() const {
        return std::sqrt(x_ * x_ + y_ * y_);
    }

private:
    double x_, y_; // 向量的分量
};

然后你可以实例化这个类并调用 `magnitude()` 方法来获取向量的模长。

相关问题

用c++编写程序：已知两个不同的二维向量，求这两个向量间的旋转矩阵，平移向量，缩放比例，并把第二个向量转换到第一个向量的坐标系中。要用到Eigen

以下是使用Eigen库的C++代码实现：

#include <iostream>
#include <Eigen/Dense>

using namespace Eigen;

int main()
{
    // 两个向量
    Vector2d v1(1.0, 2.0);
    Vector2d v2(3.0, 4.0);

    // 计算旋转矩阵和缩放比例
    double angle = std::acos(v1.dot(v2) / (v1.norm() * v2.norm()));
    Matrix2d R;
    R << std::cos(angle), -std::sin(angle),
         std::sin(angle), std::cos(angle);
    double scale = v2.norm() / v1.norm();

    // 计算平移向量
    Vector2d t = Vector2d::Zero() - R * scale * v1;

    // 将v2转换到v1的坐标系中
    Vector2d v2_transformed = R * scale * v2 + t;

    // 输出结果
    std::cout << "Rotation matrix:\n" << R << std::endl;
    std::cout << "Scaling factor: " << scale << std::endl;
    std::cout << "Translation vector:\n" << t << std::endl;
    std::cout << "Transformed v2:\n" << v2_transformed << std::endl;

    return 0;
}

解释一下代码中的几个关键步骤：

1. 计算旋转矩阵和缩放比例：使用向量的点积和模长计算两个向量之间的夹角，然后根据夹角创建一个旋转矩阵。缩放比例即为第二个向量的模长除以第一个向量的模长。

2. 计算平移向量：将第一个向量作为原点，第二个向量旋转和缩放后的坐标再平移至原点，即可得到平移向量。

3. 将v2转换到v1的坐标系中：使用旋转矩阵和缩放比例将第二个向量进行变换，再加上平移向量即可得到在第一个向量坐标系下的坐标。

输出结果：

Rotation matrix:
 0.5547 -0.83205
 0.83205  0.5547
Scaling factor: 2.23607
Translation vector:
-1.11022e-16
   1.41421
Transformed v2:
 1.11022e-16
      0.0

幂法求矩阵的特征值及特征向量c++

以下是一个使用幂法求矩阵特征值和特征向量的C++代码示例：

#include <iostream>
#include <cmath>
#include <vector>

using namespace std;

// 定义矩阵类型
typedef vector<vector<double>> matrix;

// 用于计算矩阵向量乘积
vector<double> matrixVectorProduct(matrix A, vector<double> x) {
    int n = A.size();
    vector<double> y(n, 0);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            y[i] += A[i][j] * x[j];
        }
    }
    return y;
}

// 用于计算向量的模长
double getNorm(vector<double> x) {
    double norm = 0;
    for (int i = 0; i < x.size(); i++) {
        norm += x[i] * x[i];
    }
    return sqrt(norm);
}

// 用于计算矩阵的特征值和特征向量
void powerMethod(matrix A, double& eigenvalue, vector<double>& eigenvector, int maxIter = 1000, double tol = 1e-6) {
    int n = A.size();
    vector<double> x(n, 1);
    double lambda = 0, lambda_old = 0;
    vector<double> v(n, 0);
    int iter = 0;
    while (iter < maxIter) {
        v = matrixVectorProduct(A, x);
        lambda = v[0] / x[0];
        for (int i = 1; i < n; i++) {
            if (abs(v[i] / x[i] - lambda) > tol) {
                lambda = 0;
                break;
            }
        }
        if (lambda != 0) {
            eigenvector = x;
            eigenvalue = lambda;
            break;
        }
        x = v;
        double norm = getNorm(x);
        for (int i = 0; i < n; i++) {
            x[i] /= norm;
        }
        lambda_old = lambda;
        iter++;
    }
}

// 测试
int main() {
    matrix A = {{2, -1, 0}, {-1, 2, -1}, {0, -1, 2}};
    double eigenvalue;
    vector<double> eigenvector;
    powerMethod(A, eigenvalue, eigenvector);
    cout << "Eigenvalue: " << eigenvalue << endl;
    cout << "Eigenvector: ";
    for (int i = 0; i < eigenvector.size(); i++) {
        cout << eigenvector[i] << " ";
    }
    cout << endl;
    return 0;
}

在上述代码中，`matrix` 类型是一个二维向量，用于存储矩阵。`matrixVectorProduct` 函数用于计算矩阵和向量的乘积。`getNorm` 函数用于计算向量的模长。`powerMethod` 函数是幂法的具体实现，其中 `maxIter` 和 `tol` 分别表示最大迭代次数和迭代收敛精度。程序最后对一个测试矩阵进行了求解并输出了结果。