벡터 크기 및 길이 계산 - 소프트웨어 융합

벡터의 크기 정의

벡터의 크기, 즉 벡터의 길이(norm)는 주로 유클리드 거리(Euclidean distance)를 통해 정의된다. $n$ 차원 공간에서 벡터 $\mathbf{v}$ 의 크기는 다음과 같이 정의된다.

$\|\mathbf{v}\| = \sqrt{v_1^2 + v_2^2 + \cdots + v_n^2}$

여기서 $\mathbf{v}$ 는 $n$ 차원의 벡터로, 각 성분 $v_1, v_2, \cdots, v_n$ 은 벡터의 구성 요소이다.

이를 일반적으로 $\ell_2$ -놈( $\ell_2$ -norm)이라고 하며, 유클리드 벡터 공간에서 가장 자주 사용되는 놈이다.

Eigen을 사용한 벡터 크기 계산

Eigen 라이브러리를 사용하여 벡터의 크기를 계산하는 방법을 예시 코드로 설명하겠다. Eigen에서 벡터의 크기(norm)를 계산하기 위해서는 norm() 함수를 사용할 수 있다.

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

int main() {
    Eigen::Vector3d v(3.0, 4.0, 0.0);  // 3차원 벡터 생성
    double norm = v.norm();             // 벡터의 크기 계산
    std::cout << "벡터의 크기: " << norm << std::endl;  // 결과 출력
    return 0;
}

위 예제에서는 3차원 벡터 $\mathbf{v} = (3, 4, 0)$ 의 크기를 계산하고 있다. 결과는 벡터의 크기 $\|\mathbf{v}\|$ 로, $\sqrt{3^2 + 4^2} = 5$ 가 출력된다.

$\ell_1$ -놈 (Manhattan 거리)

벡터의 크기를 정의하는 다른 방식으로는 $\ell_1$ -놈이 있다. 이는 각 성분의 절댓값의 합으로 정의되며, 종종 Manhattan 거리라고도 한다. 벡터 $\mathbf{v}$ 에 대한 $\ell_1$ -놈은 다음과 같이 계산된다.

$\|\mathbf{v}\|_1 = |v_1| + |v_2| + \cdots + |v_n|$

Eigen에서는 $\ell_1$ -놈을 lpNorm<1>() 함수를 사용하여 계산할 수 있다.

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

int main() {
    Eigen::Vector3d v(3.0, -4.0, 2.0);  // 3차원 벡터 생성
    double l1_norm = v.lpNorm<1>();     // 벡터의 L1 놈 계산
    std::cout << "벡터의 L1 놈: " << l1_norm << std::endl;  // 결과 출력
    return 0;
}

이 예제에서는 $\mathbf{v} = (3, -4, 2)$ 의 $\ell_1$ -놈을 계산하며, 결과는 $|3| + |-4| + |2| = 9$ 가 출력된다.

$\ell_\infty$ -놈 (최대 놈)

벡터의 크기를 정의하는 또 다른 방식으로는 $\ell_\infty$ -놈이 있다. 이는 벡터 성분 중 절댓값이 가장 큰 성분의 값으로 정의되며, 최대 놈 또는 Chebyshev 놈이라고도 불린다. $\mathbf{v}$ 에 대한 $\ell_\infty$ -놈은 다음과 같이 표현된다.

$\|\mathbf{v}\|_\infty = \max (|v_1|, |v_2|, \dots, |v_n|)$

Eigen에서는 $\ell_\infty$ -놈을 lpNorm<Infinity>() 함수를 사용하여 계산할 수 있다.

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

int main() {
    Eigen::Vector3d v(3.0, -7.0, 2.0);    // 3차원 벡터 생성
    double l_inf_norm = v.lpNorm<Eigen::Infinity>();  // 벡터의 L∞ 놈 계산
    std::cout << "벡터의 L∞ 놈: " << l_inf_norm << std::endl;  // 결과 출력
    return 0;
}

이 예제에서는 $\mathbf{v} = (3, -7, 2)$ 에 대한 $\ell_\infty$ -놈을 계산하며, 결과는 $\max (|3|, |-7|, |2|) = 7$ 이 출력된다.

벡터 크기의 다른 놈 (임의의 p-놈)

일반화된 $\ell_p$ -놈은 다음과 같이 정의된다.

$\|\mathbf{v}\|_p = \left( |v_1|^p + |v_2|^p + \cdots + |v_n|^p \right)^{1/p}$

$p$ -놈은 $p$ 가 1일 때 $\ell_1$ -놈, $p$ 가 2일 때 $\ell_2$ -놈, $p$ 가 무한대( $\infty$ )일 때는 $\ell_\infty$ -놈으로 귀결된다. 임의의 $p$ 값에 대한 놈을 계산하려면 Eigen의 lpNorm<p>() 함수 템플릿을 사용할 수 있다.

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

int main() {
    Eigen::Vector3d v(1.0, 2.0, 3.0);    // 3차원 벡터 생성
    double p_norm = v.lpNorm<3>();       // 벡터의 L3 놈 계산 (p=3)
    std::cout << "벡터의 L3 놈: " << p_norm << std::endl;  // 결과 출력
    return 0;
}

이 코드는 $\mathbf{v} = (1, 2, 3)$ 에 대해 $p=3$ 인 $\ell_3$ -놈을 계산하며, 그 결과는 다음과 같이 계산된다.

$\|\mathbf{v}\|_3 = \left( |1|^3 + |2|^3 + |3|^3 \right)^{1/3} = \left( 1 + 8 + 27 \right)^{1/3} = 3.3019$

이와 같이, 놈은 다양한 $p$ 값에 따라 벡터의 크기를 다르게 측정하는 수단을 제공한다.

놈의 성질

놈은 몇 가지 중요한 성질을 갖는다. 이를 수학적으로 표현하면 다음과 같다.

양의 정부호성(Positive Definiteness):

$\|\mathbf{v}\| \geq 0, \quad \text{그리고} \quad \|\mathbf{v}\| = 0 \iff \mathbf{v} = \mathbf{0}$

놈은 항상 0 이상의 값을 가지며, 벡터가 0인 경우에만 놈이 0이 된다.

동차성(Scalar Multiplication):

$\|\alpha \mathbf{v}\| = |\alpha| \|\mathbf{v}\|$

벡터를 스칼라 $\alpha$ 로 곱했을 때, 놈의 크기는 $\alpha$ 의 절댓값에 비례한다.

삼각 부등식(Triangle Inequality):

$\|\mathbf{v} + \mathbf{w}\| \leq \|\mathbf{v}\| + \|\mathbf{w}\|$

두 벡터의 합의 크기는 각 벡터 크기의 합보다 작거나 같다.

이러한 성질들은 벡터 공간에서 놈이 가지는 중요한 특성으로, 벡터의 크기나 거리 등을 다룰 때 유용하게 활용된다.

놈의 적용 예: 벡터 간 거리 계산

놈은 단순히 벡터의 크기를 측정하는 데 그치지 않고, 벡터 간의 거리를 계산하는 데도 사용된다. 두 벡터 $\mathbf{v}$ 와 $\mathbf{w}$ 사이의 거리는 두 벡터의 차이 벡터의 놈을 계산하여 구할 수 있다.

$\text{distance}(\mathbf{v}, \mathbf{w}) = \|\mathbf{v} - \mathbf{w}\|$

Eigen에서는 다음과 같이 두 벡터 사이의 거리를 계산할 수 있다.

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

int main() {
    Eigen::Vector3d v(1.0, 2.0, 3.0);  // 첫 번째 벡터
    Eigen::Vector3d w(4.0, 0.0, 3.0);  // 두 번째 벡터
    double distance = (v - w).norm();  // 두 벡터 간의 거리 계산
    std::cout << "두 벡터 사이의 거리: " << distance << std::endl;  // 결과 출력
    return 0;
}

이 예제에서는 $\mathbf{v} = (1, 2, 3)$ 와 $\mathbf{w} = (4, 0, 3)$ 사이의 거리를 계산하고 있다. 그 결과는 다음과 같다.

$\|\mathbf{v} - \mathbf{w}\| = \sqrt{(1 - 4)^2 + (2 - 0)^2 + (3 - 3)^2} = \sqrt{9 + 4 + 0} = \sqrt{13} = 3.605$

이는 두 벡터 간의 유클리드 거리로, 놈을 이용해 쉽게 구할 수 있다.

벡터의 단위 벡터 계산

단위 벡터(unit vector)는 크기가 1인 벡터로, 원래 벡터와 동일한 방향을 갖는다. 임의의 벡터 $\mathbf{v}$ 에 대해 단위 벡터 $\mathbf{u}$ 는 다음과 같이 계산된다.

$\mathbf{u} = \frac{\mathbf{v}}{\|\mathbf{v}\|}$

Eigen을 사용하여 단위 벡터를 계산하는 방법은 아래와 같다. normalized() 함수를 사용하면 벡터를 자동으로 크기 1로 정규화할 수 있다.

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

int main() {
    Eigen::Vector3d v(3.0, 4.0, 0.0);    // 3차원 벡터 생성
    Eigen::Vector3d unit_v = v.normalized();  // 벡터의 단위 벡터 계산
    std::cout << "단위 벡터: \n" << unit_v << std::endl;  // 결과 출력
    return 0;
}

이 예제에서는 벡터 $\mathbf{v} = (3, 4, 0)$ 에 대해 단위 벡터를 계산하고 있으며, 그 결과는 다음과 같다.

$\mathbf{u} = \frac{1}{5}(3, 4, 0) = (0.6, 0.8, 0.0)$

벡터의 크기가 1인 것을 확인할 수 있으며, 방향은 원래 벡터와 동일한다.

벡터 크기 계산의 응용: 기하학적 의미

벡터의 크기와 놈은 기하학적으로 매우 중요한 역할을 한다. 이를 통해 벡터 간의 관계나 기하학적 성질을 분석할 수 있다.

벡터의 방향과 각도 계산: 두 벡터 $\mathbf{v}$ 와 $\mathbf{w}$ 사이의 각도 $\theta$ 는 다음과 같은 식으로 계산할 수 있다.

$\cos \theta = \frac{\mathbf{v} \cdot \mathbf{w}}{\|\mathbf{v}\| \|\mathbf{w}\|}$

Eigen에서는 dot() 함수를 사용하여 내적을 계산할 수 있다.

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

int main() {
    Eigen::Vector3d v(1.0, 0.0, 0.0);  // 첫 번째 벡터
    Eigen::Vector3d w(0.0, 1.0, 0.0);  // 두 번째 벡터
    double dot_product = v.dot(w);     // 두 벡터의 내적 계산
    double angle = acos(dot_product / (v.norm() * w.norm()));  // 두 벡터 사이의 각도 계산
    std::cout << "두 벡터 사이의 각도(라디안): " << angle << std::endl;  // 결과 출력
    return 0;
}

이 예제에서는 $\mathbf{v} = (1, 0, 0)$ 와 $\mathbf{w} = (0, 1, 0)$ 의 내적을 사용하여 두 벡터가 직교(orthogonal)함을 확인할 수 있다. 각도는 90도, 즉 $\frac{\pi}{2}$ 라디안이 된다.

프로젝션(Projection): 벡터 $\mathbf{v}$ 가 벡터 $\mathbf{w}$ 위로의 정사영(프로젝션)은 다음과 같이 계산된다.

$\text{proj}_{\mathbf{w}} \mathbf{v} = \frac{\mathbf{v} \cdot \mathbf{w}}{\|\mathbf{w}\|^2} \mathbf{w}$

Eigen을 사용하여 벡터의 프로젝션을 계산하는 코드는 다음과 같다.

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

int main() {
    Eigen::Vector3d v(1.0, 2.0, 3.0);  // 첫 번째 벡터
    Eigen::Vector3d w(0.0, 1.0, 0.0);  // 두 번째 벡터
    Eigen::Vector3d projection = (v.dot(w) / w.squaredNorm()) * w;  // 벡터 v를 w에 사영
    std::cout << "프로젝션: \n" << projection << std::endl;  // 결과 출력
    return 0;
}

이 예제에서는 벡터 $\mathbf{v} = (1, 2, 3)$ 를 벡터 $\mathbf{w} = (0, 1, 0)$ 에 사영하여 그 결과를 계산하고 있다.