# C++에서 마르코프 확률 과정 (Markov Stochastic Process in C++)

#### 개요

C++에서 마르코프 확률 과정을 구현하는 것은 이산 및 연속 상태 공간에서 상태 전이 모델을 효과적으로 시뮬레이션하고 분석하는 강력한 도구를 제공한다. C++의 고성능과 강력한 메모리 관리 기능은 복잡한 확률 과정의 시뮬레이션 및 분석에 매우 유용하다. 이 섹션에서는 C++을 사용하여 마르코프 확률 과정을 구현하는 방법을 설명하고, 상태 전이 행렬의 정의, 확률 계산, 그리고 결과 분석을 중심으로 논의한다.

#### 상태 전이 행렬의 정의 및 관리

마르코프 확률 과정의 중심은 상태 전이 행렬(Transition Matrix)이다. C++에서는 이 행렬을 2차원 배열 또는 벡터로 구현할 수 있다. 특히, `std::vector<std::vector<double>>`를 사용하여 행렬을 동적으로 관리할 수 있다.

다음은 상태 전이 행렬을 정의하는 예제 코드이다.

```cpp
#include <vector>
#include <iostream>

class MarkovProcess {
private:
    std::vector<std::vector<double>> transitionMatrix;

public:
    MarkovProcess(int states) {
        transitionMatrix.resize(states, std::vector<double>(states, 0.0));
    }

    void setTransitionProbability(int from, int to, double probability) {
        transitionMatrix[from][to] = probability;
    }

    double getTransitionProbability(int from, int to) const {
        return transitionMatrix[from][to];
    }

    void printTransitionMatrix() const {
        for (const auto& row : transitionMatrix) {
            for (double prob : row) {
                std::cout << prob << " ";
            }
            std::cout << std::endl;
        }
    }
};
```

위 코드에서 `MarkovProcess` 클래스는 상태 전이 행렬을 관리하는 기본적인 구조를 제공한다. 상태 전이 확률은 `setTransitionProbability` 메서드를 통해 정의할 수 있으며, `getTransitionProbability` 메서드를 통해 특정 상태 전이의 확률을 얻을 수 있다.

#### 상태 전이 및 시뮬레이션

마르코프 확률 과정의 시뮬레이션은 상태 전이 행렬을 사용하여 각 상태에서 다음 상태로의 전이를 시뮬레이션하는 것을 의미한다. 이를 위해서는 난수 생성기(Random Number Generator)와 누적 확률(Cumulative Probability)을 사용하여 다음 상태를 결정할 수 있다. C++에서는 표준 라이브러리의 `std::mt19937` 및 `std::uniform_real_distribution`을 이용하여 난수를 생성할 수 있다.

다음은 상태 전이를 시뮬레이션하는 코드 예제이다.

```cpp
#include <random>

class MarkovProcess {
    // 기존 코드와 동일

public:
    int simulateNextState(int currentState) {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_real_distribution<> dis(0.0, 1.0);

        double randomValue = dis(gen);
        double cumulativeProbability = 0.0;

        for (size_t nextState = 0; nextState < transitionMatrix[currentState].size(); ++nextState) {
            cumulativeProbability += transitionMatrix[currentState][nextState];
            if (randomValue <= cumulativeProbability) {
                return nextState;
            }
        }

        return currentState;  // 예외적 상황, 모든 확률이 0인 경우
    }
};
```

위 코드에서 `simulateNextState` 메서드는 주어진 현재 상태에서 다음 상태로의 전이를 시뮬레이션한다. 이 방법은 주어진 상태의 전이 확률을 누적하고, 생성된 난수를 누적 확률에 대응시켜 다음 상태를 결정한다.

#### 초기 분포 및 장기 거동 분석

마르코프 체인의 초기 상태 분포는 상태 전이가 시작될 때 시스템의 상태를 결정하는 데 사용된다. 이를 `std::vector<double>`로 정의할 수 있으며, 이는 각 상태에서의 초기 확률을 나타낸다.

또한, 장기적으로 시스템이 어떤 상태에 수렴하는지 분석하기 위해서는 여러 번의 시뮬레이션을 실행하여 장기적인 분포를 관찰할 수 있다. 이는 상태 전이 행렬의 거듭제곱을 사용하거나, 시뮬레이션 결과를 기반으로 반복적으로 계산하여 분석할 수 있다.

다음은 장기 거동을 분석하는 간단한 예제이다.

```cpp
std::vector<double> analyzeLongTermBehavior(MarkovProcess& process, int initialState, int iterations) {
    std::vector<double> stateCounts(process.getStateCount(), 0);
    int currentState = initialState;

    for (int i = 0; i < iterations; ++i) {
        stateCounts[currentState]++;
        currentState = process.simulateNextState(currentState);
    }

    // 확률로 변환
    for (auto& count : stateCounts) {
        count /= iterations;
    }

    return stateCounts;
}
```

위 코드는 주어진 초기 상태에서 시작하여 다수의 시뮬레이션을 수행한 후, 각 상태에 대한 장기적인 점유 확률을 계산한다. 이 결과를 통해 마르코프 체인의 에르고딕성을 확인할 수 있다.

#### 메모리 관리 및 최적화

C++에서는 메모리 관리가 중요한 역할을 한다. 특히, 상태 전이 행렬이 크거나 시뮬레이션이 다수의 반복을 필요로 할 때, 효율적인 메모리 사용과 최적화가 필요하다. 예를 들어, Sparse Matrix(희소 행렬)를 사용하거나, 멀티스레딩을 통해 시뮬레이션을 병렬화하는 방법이 있다.

다음은 희소 행렬을 사용한 최적화 예제이다.

```cpp
#include <unordered_map>

class SparseMarkovProcess {
private:
    std::unordered_map<int, std::unordered_map<int, double>> transitionMatrix;

public:
    void setTransitionProbability(int from, int to, double probability) {
        transitionMatrix[from][to] = probability;
    }

    double getTransitionProbability(int from, int to) const {
        auto it = transitionMatrix.find(from);
        if (it != transitionMatrix.end()) {
            auto jt = it->second.find(to);
            if (jt != it->second.end()) {
                return jt->second;
            }
        }
        return 0.0;
    }
};
```

이 코드에서 `SparseMarkovProcess` 클래스는 희소 행렬을 구현하기 위해 `std::unordered_map`을 사용한다. 이는 메모리 효율성을 높이며, 특히 전이 확률이 0인 요소가 많은 경우에 유리하다.