VHDLにおける二次元配列の初期化方法と活用10選

●VHDLの二次元配列とは？
●VHDLでの二次元配列初期化テクニック
●FPGAデザインにおける二次元配列の活用
●よくあるエラーと対処法
●二次元配列の応用例
まとめ

●VHDLの二次元配列とは？

VHDLは、ハードウェア記述言語として広く使われています。

多くのエンジニアが日々VHDLを駆使して、複雑な電子回路を設計しています。

その中でも、二次元配列は非常に重要な役割を果たします。

二次元配列を使うと、データを行と列で構成された表形式で扱うことができます。

電子回路設計において、二次元配列はマトリックス演算や画像処理など、様々な場面で活躍します。

たとえば、ディスプレイの各ピクセルの色情報を格納したり、大規模な行列計算を行ったりする際に便利です。

二次元配列を適切に初期化することは、プログラムの正確性と効率性を確保するために欠かせません。

初期化を怠ると、予期せぬバグや誤動作の原因となる可能性があります。

○二次元配列の基本概念と利点

二次元配列は、一次元配列を拡張したものです。

一次元配列が直線状にデータを並べるのに対し、二次元配列は表のようにデータを配置します。

行と列の概念を持つため、データの構造化がより intuitive になります。

二次元配列の主な利点は、データの整理と取り扱いが容易になることです。

例えば、チェス盤の状態を表現する場合、8×8の二次元配列を使うと、各マスの状態を直感的に管理できます。

また、二次元配列は計算の効率化にも貢献します。

行列演算や畳み込み演算などの複雑な数学的操作を、シンプルなループ構造で実現できます。

○VHDLにおける二次元配列の宣言方法

VHDLで二次元配列を宣言する際は、型定義と変数宣言の2段階で行います。

まず、配列の型を定義し、次にその型を使って変数を宣言します。

型定義の例

type matrix_type is array (0 to 3, 0 to 3) of integer;

この例では、4×4の整数型二次元配列の型を定義しています。

変数宣言の例

variable my_matrix : matrix_type;

ここでは、先ほど定義した型を使って実際の変数を宣言しています。

○サンプルコード1：基本的な二次元配列の宣言と初期化

それでは、実際のコードを見てみましょう。

ここでは、3×3の整数型二次元配列を宣言し、初期化する例を紹介します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity array_example is
end array_example;

architecture Behavioral of array_example is
    type matrix_3x3 is array (0 to 2, 0 to 2) of integer;
    signal my_matrix : matrix_3x3 := (
        (1, 2, 3),
        (4, 5, 6),
        (7, 8, 9)
    );
begin
    -- ここに処理を記述
end Behavioral;

このコードでは、matrix_3x3という型を定義し、my_matrixという信号を宣言しています。

初期化では、各要素に1から9までの値を設定しています。

VHDLの二次元配列は、このように直感的に宣言と初期化ができます。

行と列の数を自由に設定できるので、様々なサイズのデータ構造を表現できます。

●VHDLでの二次元配列初期化テクニック

二次元配列の初期化は、データの構造や用途によって異なる方法が求められます。

VHDLは柔軟な初期化方法を提供しており、静的初期化と動的初期化の2つの主要なアプローチがあります。

○静的初期化vs動的初期化

静的初期化は、配列の値をコード内で直接指定する方法です。

設計時に値が既知である場合に使用します。

例えば、定数テーブルや固定パターンを表現する際に便利です。

一方、動的初期化は、プログラムの実行中に値を設定する方法です。

ループや条件分岐を使って、より複雑なパターンや計算結果に基づいた初期化が可能です。

静的初期化のメリットは、コードが直感的で読みやすいことです。

しかし、大規模な配列や複雑なパターンの場合、コードが冗長になる可能性があります。

動的初期化は、より柔軟性が高く、大規模なデータ構造や複雑なパターンの初期化に適しています。

ただし、合成ツールによっては、動的初期化の一部の形式をサポートしていない場合があるので注意が必要です。

○サンプルコード2：静的初期化の実装例

静的初期化の典型的な例を見てみましょう。

ここでは、4×4のチェスボードの初期配置を表現します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity chess_board is
end chess_board;

architecture Behavioral of chess_board is
    type piece is (empty, pawn, rook, knight, bishop, queen, king);
    type board is array (0 to 3, 0 to 3) of piece;

    constant initial_board : board := (
        (rook,  knight, bishop, queen),
        (pawn,  pawn,   pawn,   pawn),
        (empty, empty,  empty,  empty),
        (pawn,  pawn,   pawn,   pawn)
    );
begin
    -- ここに処理を記述
end Behavioral;

このコードでは、チェスの駒を表す列挙型pieceと、4×4のボードを表すboard型を定義しています。

initial_board定数で、チェスの初期配置を静的に初期化しています。

静的初期化は、デバッグが容易で、コードの意図が明確です。

しかし、大規模な配列では冗長になる可能性があります。

○サンプルコード3：ループを使用した動的初期化

次に、ループを使用した動的初期化の例を見てみましょう。

この例では、5×5の行列を作成し、対角線上に1を、それ以外に0を設定します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity diagonal_matrix is
end diagonal_matrix;

architecture Behavioral of diagonal_matrix is
    type matrix_5x5 is array (0 to 4, 0 to 4) of integer;
    signal my_matrix : matrix_5x5;

begin
    process
    begin
        for i in 0 to 4 loop
            for j in 0 to 4 loop
                if i = j then
                    my_matrix(i, j) <= 1;
                else
                    my_matrix(i, j) <= 0;
                end if;
            end loop;
        end loop;
        wait;
    end process;
end Behavioral;

このコードでは、二重ループを使用して5×5の行列を初期化しています。

対角線上（i = j）の要素には1を、それ以外の要素には0を設定しています。

動的初期化の利点は、複雑なパターンや大規模な配列を効率的に初期化できることです。

また、初期化ロジックを変更するのも容易です。

○サンプルコード4：関数を利用した高度な初期化

より複雑な初期化パターンには、関数を使用すると便利です。

ここでは、フィボナッチ数列を使って4×4の行列を初期化する例を紹介します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity fibonacci_matrix is
end fibonacci_matrix;

architecture Behavioral of fibonacci_matrix is
    type matrix_4x4 is array (0 to 3, 0 to 3) of integer;
    signal fib_matrix : matrix_4x4;

    function fibonacci(n : integer) return integer is
    begin
        if n = 0 or n = 1 then
            return n;
        else
            return fibonacci(n-1) + fibonacci(n-2);
        end if;
    end function;

begin
    process
    begin
        for i in 0 to 3 loop
            for j in 0 to 3 loop
                fib_matrix(i, j) <= fibonacci(i*4 + j);
            end loop;
        end loop;
        wait;
    end process;
end Behavioral;

このコードでは、fibonacci関数を定義し、各要素の位置に対応するフィボナッチ数を計算して初期化しています。

関数を使用した初期化は、複雑な数学的パターンや特殊なデータ構造の生成に適しています。

コードの再利用性も高まり、保守性が向上します。

●FPGAデザインにおける二次元配列の活用

FPGAデザインの分野では、二次元配列が大いに活躍します。

複雑なデータ構造や大規模な計算を効率的に処理するために、二次元配列は欠かせない存在となっています。

FPGAエンジニアにとって、二次元配列の活用法を習得することは、プロジェクトの成功に直結する重要なスキルです。

○メモリマップドデザインでの利用

メモリマップドデザインは、FPGAの性能を最大限に引き出すための重要な手法です。

二次元配列を使用することで、複雑なメモリ構造を直感的に表現できます。

例えば、画像処理やビデオ処理において、フレームバッファを二次元配列として実装することで、ピクセルデータへのアクセスが容易になります。

メモリマップドデザインでは、二次元配列を使用して、物理的なメモリレイアウトと論理的なデータ構造を対応させます。

行と列のインデックスを使用して、特定のメモリ位置にアクセスできるため、データの読み書きが高速かつ効率的に行えます。

○サンプルコード5：画像処理アルゴリズムの実装

画像処理は、FPGAの並列処理能力を活かせる分野です。

二次元配列を使用して、画像データを効率的に扱うことができます。

ここでは、簡単なエッジ検出アルゴリズムを実装したサンプルコードを見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity edge_detection is
    generic (
        WIDTH  : integer := 640;
        HEIGHT : integer := 480
    );
    port (
        clk      : in  std_logic;
        reset    : in  std_logic;
        pixel_in : in  std_logic_vector(7 downto 0);
        pixel_out: out std_logic_vector(7 downto 0)
    );
end edge_detection;

architecture Behavioral of edge_detection is
    type image_buffer is array (0 to 2, 0 to WIDTH-1) of unsigned(7 downto 0);
    signal buffer_rows : image_buffer;
    signal row_count   : integer range 0 to HEIGHT-1 := 0;
    signal col_count   : integer range 0 to WIDTH-1  := 0;
begin
    process(clk, reset)
        variable sum : integer;
    begin
        if reset = '1' then
            row_count <= 0;
            col_count <= 0;
        elsif rising_edge(clk) then
            -- シフトバッファの更新
            for i in 2 downto 1 loop
                buffer_rows(i, col_count) <= buffer_rows(i-1, col_count);
            end loop;
            buffer_rows(0, col_count) <= unsigned(pixel_in);

            -- エッジ検出の計算
            if row_count > 1 and col_count > 0 and col_count < WIDTH-1 then
                sum := to_integer(buffer_rows(0, col_count-1)) +
                       to_integer(buffer_rows(0, col_count+1)) +
                       to_integer(buffer_rows(2, col_count-1)) +
                       to_integer(buffer_rows(2, col_count+1)) -
                       4 * to_integer(buffer_rows(1, col_count));

                if sum < 0 then sum := 0;
                elsif sum > 255 then sum := 255;
                end if;

                pixel_out <= std_logic_vector(to_unsigned(sum, 8));
            else
                pixel_out <= (others => '0');
            end if;

            -- カウンターの更新
            if col_count = WIDTH-1 then
                col_count <= 0;
                if row_count = HEIGHT-1 then
                    row_count <= 0;
                else
                    row_count <= row_count + 1;
                end if;
            else
                col_count <= col_count + 1;
            end if;
        end if;
    end process;
end Behavioral;

このコードでは、image_bufferという二次元配列を使用して、画像の3行分のデータをバッファリングしています。

エッジ検出アルゴリズムは、中央のピクセルと周囲のピクセルの差分を計算することで実現しています。

二次元配列を使用することで、画像データの空間的な関係を維持しながら、効率的に処理を行うことができます。

○サンプルコード6：大規模データ管理システムの構築

FPGAは大規模なデータ処理にも適しています。

例えば、センサーネットワークからのデータを管理するシステムを考えてみましょう。

二次元配列を使用して、多数のセンサーからのデータを効率的に格納し、処理することができます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity sensor_data_manager is
    generic (
        NUM_SENSORS : integer := 100;
        DATA_HISTORY: integer := 1000
    );
    port (
        clk           : in  std_logic;
        reset         : in  std_logic;
        sensor_id     : in  unsigned(6 downto 0);
        sensor_data   : in  std_logic_vector(15 downto 0);
        data_valid    : in  std_logic;
        query_sensor  : in  unsigned(6 downto 0);
        query_index   : in  unsigned(9 downto 0);
        query_data    : out std_logic_vector(15 downto 0)
    );
end sensor_data_manager;

architecture Behavioral of sensor_data_manager is
    type sensor_array is array (0 to NUM_SENSORS-1, 0 to DATA_HISTORY-1) of unsigned(15 downto 0);
    signal sensor_data_buffer : sensor_array;
    signal write_index : unsigned(9 downto 0) := (others => '0');
begin
    process(clk, reset)
    begin
        if reset = '1' then
            write_index <= (others => '0');
            sensor_data_buffer <= (others => (others => (others => '0')));
        elsif rising_edge(clk) then
            if data_valid = '1' then
                sensor_data_buffer(to_integer(sensor_id), to_integer(write_index)) <= unsigned(sensor_data);
                if write_index = DATA_HISTORY - 1 then
                    write_index <= (others => '0');
                else
                    write_index <= write_index + 1;
                end if;
            end if;

            query_data <= std_logic_vector(sensor_data_buffer(to_integer(query_sensor), to_integer(query_index)));
        end if;
    end process;
end Behavioral;

この例では、sensor_arrayという二次元配列を使用して、100個のセンサーから1000個のデータポイントを格納しています。

各センサーからのデータは、対応する行に順次格納されます。

また、特定のセンサーの特定のデータポイントにアクセスするクエリ機能も実装されています。

二次元配列を使用することで、大量のデータを整理された形で管理でき、高速なアクセスが可能になります。

FPGAの並列処理能力と組み合わせることで、リアルタイムでの大規模データ処理が実現できます。

●よくあるエラーと対処法

VHDLで二次元配列を使用する際、いくつかの一般的なエラーに遭遇することがあります。

このエラーを理解し、適切に対処することで、より堅牢なコードを書くことができます。

○配列サイズの不一致エラー

配列サイズの不一致は、よく見られるエラーの一つです。

例えば、3×3の配列を4×4の配列に代入しようとすると、エラーが発生します。

エラー例

type matrix_3x3 is array (0 to 2, 0 to 2) of integer;
type matrix_4x4 is array (0 to 3, 0 to 3) of integer;

signal matrix_a : matrix_3x3;
signal matrix_b : matrix_4x4;

-- エラーが発生する代入
matrix_b <= matrix_a;

この問題を解決するには、配列のサイズを一致させるか、必要に応じて要素ごとにコピーする必要があります。

修正例

for i in 0 to 2 loop
    for j in 0 to 2 loop
        matrix_b(i, j) <= matrix_a(i, j);
    end loop;
end loop;
-- 残りの要素は0で埋める
for i in 3 to 3 loop
    for j in 0 to 3 loop
        matrix_b(i, j) <= 0;
    end loop;
end loop;
for j in 3 to 3 loop
    for i in 0 to 2 loop
        matrix_b(i, j) <= 0;
    end loop;
end loop;

○初期化値の型不一致エラー

配列の要素の型と初期化値の型が一致しないと、エラーが発生します。

エラー例

type float_matrix is array (0 to 2, 0 to 2) of real;
signal my_matrix : float_matrix := (
    (1, 2, 3),  -- 整数リテラルを使用
    (4, 5, 6),
    (7, 8, 9)
);

VHDLでは、整数リテラルを実数型に自動的に変換しないため、この初期化はエラーになります。

修正例

type float_matrix is array (0 to 2, 0 to 2) of real;
signal my_matrix : float_matrix := (
    (1.0, 2.0, 3.0),  -- 実数リテラルを使用
    (4.0, 5.0, 6.0),
    (7.0, 8.0, 9.0)
);

○メモリ不足エラーの対処

FPGAのリソースには限りがあるため、大きすぎる二次元配列を宣言すると、メモリ不足エラーが発生する可能性があります。

このエラーは、合成ツールがデザインをFPGAにマッピングしようとする際に発生します。

対処法としては、次のアプローチがあります。

配列サイズの最適化 -> 必要最小限のサイズに配列を縮小します。
メモリの分割 -> 大きな配列を複数の小さな配列に分割します。
外部メモリの使用 -> FPGAの内部メモリではなく、外部SDRAMなどを使用します。

例えば、10000×10000の大きな配列を処理する必要がある場合、次のように対処できます。

entity large_data_processor is
    port (
        clk         : in  std_logic;
        reset       : in  std_logic;
        data_in     : in  std_logic_vector(15 downto 0);
        address_row : in  unsigned(13 downto 0);  -- 0-9999
        address_col : in  unsigned(13 downto 0);  -- 0-9999
        write_en    : in  std_logic;
        data_out    : out std_logic_vector(15 downto 0)
    );
end large_data_processor;

architecture Behavioral of large_data_processor is
    type block_array is array (0 to 99, 0 to 99) of std_logic_vector(15 downto 0);
    type memory_array is array (0 to 99) of block_array;
    signal data_memory : memory_array;
begin
    process(clk, reset)
        variable block_row : integer;
        variable block_col : integer;
        variable local_row : integer;
        variable local_col : integer;
    begin
        if reset = '1' then
            data_memory <= (others => (others => (others => (others => '0'))));
        elsif rising_edge(clk) then
            block_row := to_integer(address_row(13 downto 7));
            block_col := to_integer(address_col(13 downto 7));
            local_row := to_integer(address_row(6 downto 0));
            local_col := to_integer(address_col(6 downto 0));

            if write_en = '1' then
                data_memory(block_row)(block_col)(local_row)(local_col) <= data_in;
            end if;

            data_out <= data_memory(block_row)(block_col)(local_row)(local_col);
        end if;
    end process;
end Behavioral;

この例では、10000×10000の大きな配列を100×100の小さな配列100個に分割しています。

アドレス指定を適切に行うことで、元の大きな配列と同様にデータにアクセスできます。

●二次元配列の応用例

VHDLにおける二次元配列の応用範囲は広く、多様な問題解決に役立ちます。

行列演算から複雑なアルゴリズムの実装まで、二次元配列を活用することで、効率的かつ直感的なコードを書くことが可能です。

ここでは、実践的な応用例を通じて、二次元配列の威力を体感しましょう。

○サンプルコード7：行列演算の実装

行列演算は、信号処理や制御システムなど、多くの分野で重要な役割を果たします。

VHDLで行列乗算を実装する例を見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity matrix_multiplier is
    generic (
        SIZE : integer := 3
    );
    port (
        clk      : in  std_logic;
        reset    : in  std_logic;
        start    : in  std_logic;
        done     : out std_logic;
        matrix_a : in  array (0 to SIZE-1, 0 to SIZE-1) of signed(15 downto 0);
        matrix_b : in  array (0 to SIZE-1, 0 to SIZE-1) of signed(15 downto 0);
        result   : out array (0 to SIZE-1, 0 to SIZE-1) of signed(31 downto 0)
    );
end matrix_multiplier;

architecture Behavioral of matrix_multiplier is
    type state_type is (IDLE, MULTIPLY, FINISH);
    signal state : state_type := IDLE;
    signal i, j, k : integer range 0 to SIZE-1 := 0;
    signal temp_sum : signed(31 downto 0);
begin
    process(clk, reset)
    begin
        if reset = '1' then
            state <= IDLE;
            i <= 0;
            j <= 0;
            k <= 0;
            done <= '0';
        elsif rising_edge(clk) then
            case state is
                when IDLE =>
                    if start = '1' then
                        state <= MULTIPLY;
                        i <= 0;
                        j <= 0;
                        k <= 0;
                        temp_sum <= (others => '0');
                    end if;
                when MULTIPLY =>
                    temp_sum <= temp_sum + matrix_a(i, k) * matrix_b(k, j);
                    if k = SIZE-1 then
                        result(i, j) <= temp_sum;
                        k <= 0;
                        if j = SIZE-1 then
                            j <= 0;
                            if i = SIZE-1 then
                                state <= FINISH;
                            else
                                i <= i + 1;
                            end if;
                        else
                            j <= j + 1;
                        end if;
                        temp_sum <= (others => '0');
                    else
                        k <= k + 1;
                    end if;
                when FINISH =>
                    done <= '1';
                    state <= IDLE;
            end case;
        end if;
    end process;
end Behavioral;

このコードは、3×3の行列乗算を実行します。

二次元配列を使用することで、行列の要素にアクセスしやすくなり、乗算のロジックが明確になります。

ステート機械を使用して、乗算プロセスを制御しています。

○サンプルコード8：2D畳み込み演算の実現

2D畳み込み演算は、画像処理や信号処理で広く使用されるアルゴリズムです。

VHDLで2D畳み込みを実装する例を見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity convolution_2d is
    generic (
        IMG_SIZE  : integer := 64;
        KERNEL_SIZE : integer := 3
    );
    port (
        clk       : in  std_logic;
        reset     : in  std_logic;
        start     : in  std_logic;
        done      : out std_logic;
        image_in  : in  array (0 to IMG_SIZE-1, 0 to IMG_SIZE-1) of unsigned(7 downto 0);
        kernel    : in  array (0 to KERNEL_SIZE-1, 0 to KERNEL_SIZE-1) of signed(7 downto 0);
        image_out : out array (0 to IMG_SIZE-KERNEL_SIZE, 0 to IMG_SIZE-KERNEL_SIZE) of signed(15 downto 0)
    );
end convolution_2d;

architecture Behavioral of convolution_2d is
    type state_type is (IDLE, CONVOLVE, FINISH);
    signal state : state_type := IDLE;
    signal i, j, m, n : integer := 0;
    signal sum : signed(15 downto 0);
begin
    process(clk, reset)
    begin
        if reset = '1' then
            state <= IDLE;
            i <= 0;
            j <= 0;
            m <= 0;
            n <= 0;
            done <= '0';
        elsif rising_edge(clk) then
            case state is
                when IDLE =>
                    if start = '1' then
                        state <= CONVOLVE;
                        i <= 0;
                        j <= 0;
                        m <= 0;
                        n <= 0;
                        sum <= (others => '0');
                    end if;
                when CONVOLVE =>
                    sum <= sum + signed('0' & image_in(i+m, j+n)) * kernel(m, n);
                    if n = KERNEL_SIZE-1 then
                        n <= 0;
                        if m = KERNEL_SIZE-1 then
                            m <= 0;
                            image_out(i, j) <= sum;
                            sum <= (others => '0');
                            if j = IMG_SIZE-KERNEL_SIZE then
                                j <= 0;
                                if i = IMG_SIZE-KERNEL_SIZE then
                                    state <= FINISH;
                                else
                                    i <= i + 1;
                                end if;
                            else
                                j <= j + 1;
                            end if;
                        else
                            m <= m + 1;
                        end if;
                    else
                        n <= n + 1;
                    end if;
                when FINISH =>
                    done <= '1';
                    state <= IDLE;
            end case;
        end if;
    end process;
end Behavioral;

このコードは、64×64のイメージに対して3×3のカーネルを使用して2D畳み込みを実行します。

二次元配列を使用することで、イメージとカーネルの要素に効率的にアクセスできます。

○サンプルコード9：グラフ構造の表現

グラフ構造は、多くのアルゴリズムや問題で使用されます。

VHDLで隣接行列を使用してグラフを表現し、最短経路を見つける例を見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity graph_shortest_path is
    generic (
        NUM_NODES : integer := 5
    );
    port (
        clk       : in  std_logic;
        reset     : in  std_logic;
        start     : in  std_logic;
        done      : out std_logic;
        adj_matrix: in  array (0 to NUM_NODES-1, 0 to NUM_NODES-1) of unsigned(7 downto 0);
        start_node: in  unsigned(2 downto 0);
        end_node  : in  unsigned(2 downto 0);
        path_length: out unsigned(7 downto 0)
    );
end graph_shortest_path;

architecture Behavioral of graph_shortest_path is
    type state_type is (IDLE, INITIALIZE, UPDATE, CHECK, FINISH);
    signal state : state_type := IDLE;
    type distance_array is array (0 to NUM_NODES-1) of unsigned(7 downto 0);
    signal distance : distance_array;
    signal visited : std_logic_vector(NUM_NODES-1 downto 0);
    signal current_node : unsigned(2 downto 0);
begin
    process(clk, reset)
        variable min_dist : unsigned(7 downto 0);
        variable min_node : unsigned(2 downto 0);
    begin
        if reset = '1' then
            state <= IDLE;
            done <= '0';
        elsif rising_edge(clk) then
            case state is
                when IDLE =>
                    if start = '1' then
                        state <= INITIALIZE;
                    end if;
                when INITIALIZE =>
                    for i in 0 to NUM_NODES-1 loop
                        if i = to_integer(start_node) then
                            distance(i) <= to_unsigned(0, 8);
                        else
                            distance(i) <= to_unsigned(255, 8);
                        end if;
                    end loop;
                    visited <= (others => '0');
                    current_node <= start_node;
                    state <= UPDATE;
                when UPDATE =>
                    for i in 0 to NUM_NODES-1 loop
                        if visited(i) = '0' and adj_matrix(to_integer(current_node), i) /= 0 then
                            if distance(i) > distance(to_integer(current_node)) + adj_matrix(to_integer(current_node), i) then
                                distance(i) <= distance(to_integer(current_node)) + adj_matrix(to_integer(current_node), i);
                            end if;
                        end if;
                    end loop;
                    visited(to_integer(current_node)) <= '1';
                    state <= CHECK;
                when CHECK =>
                    min_dist := to_unsigned(255, 8);
                    min_node := to_unsigned(0, 3);
                    for i in 0 to NUM_NODES-1 loop
                        if visited(i) = '0' and distance(i) < min_dist then
                            min_dist := distance(i);
                            min_node := to_unsigned(i, 3);
                        end if;
                    end loop;
                    if min_dist = 255 or current_node = end_node then
                        state <= FINISH;
                    else
                        current_node <= min_node;
                        state <= UPDATE;
                    end if;
                when FINISH =>
                    path_length <= distance(to_integer(end_node));
                    done <= '1';
                    state <= IDLE;
            end case;
        end if;
    end process;
end Behavioral;

このコードは、ダイクストラのアルゴリズムを使用して、グラフの最短経路を見つけます。

隣接行列（二次元配列）を使用してグラフ構造を表現しています。

○サンプルコード10：状態遷移テーブルの実装

状態遷移テーブルは、複雑な状態機械を実装する際に便利です。

VHDLで状態遷移テーブルを使用した例を見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity state_machine is
    port (
        clk   : in  std_logic;
        reset : in  std_logic;
        input : in  std_logic_vector(1 downto 0);
        output: out std_logic_vector(1 downto 0)
    );
end state_machine;

architecture Behavioral of state_machine is
    type state_type is (S0, S1, S2, S3);
    signal current_state, next_state : state_type;

    type transition_table is array (0 to 3, 0 to 3) of state_type;
    constant state_transition : transition_table := (
        (S0, S1, S2, S3),  -- S0 transitions
        (S1, S1, S2, S3),  -- S1 transitions
        (S2, S1, S2, S3),  -- S2 transitions
        (S0, S1, S2, S3)   -- S3 transitions
    );

    type output_table is array (0 to 3) of std_logic_vector(1 downto 0);
    constant state_output : output_table := ("00", "01", "10", "11");
begin
    process(clk, reset)
    begin
        if reset = '1' then
            current_state <= S0;
        elsif rising_edge(clk) then
            current_state <= next_state;
        end if;
    end process;

    next_state <= state_transition(to_integer(unsigned(input)), state_type'pos(current_state));
    output <= state_output(state_type'pos(current_state));
end Behavioral;

このコードでは、状態遷移と出力を二次元配列と一次元配列を使用して表現しています。

状態遷移テーブルを使用することで、複雑な状態機械を簡潔に実装できます。