VHDLにおけるnot演算子の基本と活用14選

●VHDLのnot演算子とは？
●notで広がる回路設計
●VHDLアーキテクチャでのnot演算子活用法
●Quartusで学ぶnot演算子の実践
- ○サンプルコード9：Quartusでのnot演算子テスト例
- ○サンプルコード10：シミュレーションとデバッグ技法
●よくあるエラーと対処法
●not演算子の応用例
まとめ

●VHDLのnot演算子とは？

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

その中でも、not演算子は非常に重要な役割を果たします。

VHDLのnot演算子は、論理反転を行う基本的な演算子です。

入力信号の値を反転させる機能を持ち、デジタル回路設計において欠かせない存在となっています。

○not演算子の基本

not演算子の動作原理は極めてシンプルです。入力が’0’の場合は’1’を、’1’の場合は’0’を出力します。

この単純な機能が、複雑な論理回路を構築する上で重要な役割を果たします。

VHDLでnot演算子を使用する際は、通常「not」というキーワードを用います。

単項演算子として機能し、右側にある式や信号の値を反転させます。

○サンプルコード1：基本的なnot演算子の使用例

それでは、具体的なコード例を見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity NotExample is
    Port ( input : in STD_LOGIC;
           output : out STD_LOGIC);
end NotExample;

architecture Behavioral of NotExample is
begin
    output <= not input;
end Behavioral;

このコードでは、input信号の値を反転させてoutput信号に代入しています。

入力が’0’なら出力は’1’に、入力が’1’なら出力は’0’になります。

実行結果を確認してみましょう。

-- テストベンチ
entity NotExample_TB is
end NotExample_TB;

architecture Behavioral of NotExample_TB is
    signal input_sig, output_sig : STD_LOGIC;
begin
    UUT: entity work.NotExample port map (input => input_sig, output => output_sig);

    process
    begin
        input_sig <= '0';
        wait for 10 ns;
        assert output_sig = '1' report "Test failed for input '0'" severity error;

        input_sig <= '1';
        wait for 10 ns;
        assert output_sig = '0' report "Test failed for input '1'" severity error;

        wait;
    end process;
end Behavioral;

このテストベンチを実行すると、input_sigが’0’の時にoutput_sigが’1’になり、input_sigが’1’の時にoutput_sigが’0’になることが確認できます。

○比較演算子としてのnot

not演算子は単独で使用するだけでなく、他の比較演算子と組み合わせることで、より複雑な条件分岐を実現できます。

例えば、「AがBと等しくない」という条件を表現する際に、not演算子が活躍します。

○サンプルコード2：if文とnot演算子の連携

if文とnot演算子を組み合わせた例を見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity NotIfExample is
    Port ( A, B : in STD_LOGIC;
           result : out STD_LOGIC);
end NotIfExample;

architecture Behavioral of NotIfExample is
begin
    process(A, B)
    begin
        if not (A = B) then
            result <= '1';
        else
            result <= '0';
        end if;
    end process;
end Behavioral;

このコードでは、AとBが等しくない場合にresultに’1’を、等しい場合に’0’を代入しています。

not演算子をif文の条件式に組み込むことで、「等しくない」という条件を簡潔に表現しています。

実行結果を確認してみましょう。

-- テストベンチ
entity NotIfExample_TB is
end NotIfExample_TB;

architecture Behavioral of NotIfExample_TB is
    signal A_sig, B_sig, result_sig : STD_LOGIC;
begin
    UUT: entity work.NotIfExample port map (A => A_sig, B => B_sig, result => result_sig);

    process
    begin
        A_sig <= '0'; B_sig <= '0';
        wait for 10 ns;
        assert result_sig = '0' report "Test failed for A=0, B=0" severity error;

        A_sig <= '0'; B_sig <= '1';
        wait for 10 ns;
        assert result_sig = '1' report "Test failed for A=0, B=1" severity error;

        A_sig <= '1'; B_sig <= '0';
        wait for 10 ns;
        assert result_sig = '1' report "Test failed for A=1, B=0" severity error;

        A_sig <= '1'; B_sig <= '1';
        wait for 10 ns;
        assert result_sig = '0' report "Test failed for A=1, B=1" severity error;

        wait;
    end process;
end Behavioral;

このテストベンチを実行すると、AとBが異なる値の時にresult_sigが’1’になり、同じ値の時に’0’になることが確認できます。

●notで広がる回路設計

not演算子の基本的な使い方を理解したところで、より実践的な活用方法を見ていきましょう。

not演算子は、ビット反転や複雑な論理回路の設計など、様々な場面で活躍します。

○サンプルコード3：ビット反転の実装例

ビット反転は、デジタル信号処理において頻繁に使用される操作です。

VHDLでnot演算子を使用して、簡単にビット反転を実装できます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity BitInverter is
    Port ( input : in STD_LOGIC_VECTOR(7 downto 0);
           output : out STD_LOGIC_VECTOR(7 downto 0));
end BitInverter;

architecture Behavioral of BitInverter is
begin
    output <= not input;
end Behavioral;

このコードでは、8ビットの入力信号を受け取り、各ビットを反転させて出力しています。

not演算子がベクトル全体に適用されるため、一行でビット反転が実現できます。

実行結果を確認してみましょう。

-- テストベンチ
entity BitInverter_TB is
end BitInverter_TB;

architecture Behavioral of BitInverter_TB is
    signal input_sig, output_sig : STD_LOGIC_VECTOR(7 downto 0);
begin
    UUT: entity work.BitInverter port map (input => input_sig, output => output_sig);

    process
    begin
        input_sig <= "10101010";
        wait for 10 ns;
        assert output_sig = "01010101" report "Test failed for input 10101010" severity error;

        input_sig <= "11110000";
        wait for 10 ns;
        assert output_sig = "00001111" report "Test failed for input 11110000" severity error;

        wait;
    end process;
end Behavioral;

このテストベンチを実行すると、入力ビットパターンが正確に反転されていることが確認できます。

○サンプルコード4：回路設計におけるnot演算子の活用

not演算子は、より複雑な論理回路の設計にも活用できます。

例えば、エッジ検出回路の実装を見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity EdgeDetector is
    Port ( clk : in STD_LOGIC;
           input : in STD_LOGIC;
           rising_edge_detect : out STD_LOGIC;
           falling_edge_detect : out STD_LOGIC);
end EdgeDetector;

architecture Behavioral of EdgeDetector is
    signal input_delayed : STD_LOGIC := '0';
begin
    process(clk)
    begin
        if rising_edge(clk) then
            input_delayed <= input;
            rising_edge_detect <= input and (not input_delayed);
            falling_edge_detect <= (not input) and input_delayed;
        end if;
    end process;
end Behavioral;

このコードでは、入力信号の立ち上がりエッジと立ち下がりエッジを検出しています。

not演算子を使用して、現在の入力と1クロック前の入力を比較することで、エッジを検出しています。

実行結果を確認してみましょう。

-- テストベンチ
entity EdgeDetector_TB is
end EdgeDetector_TB;

architecture Behavioral of EdgeDetector_TB is
    signal clk_sig, input_sig, rising_edge_sig, falling_edge_sig : STD_LOGIC := '0';
    constant clk_period : time := 10 ns;
begin
    UUT: entity work.EdgeDetector port map (
        clk => clk_sig, 
        input => input_sig, 
        rising_edge_detect => rising_edge_sig, 
        falling_edge_detect => falling_edge_sig
    );

    -- クロック生成プロセス
    clk_process: process
    begin
        clk_sig <= '0';
        wait for clk_period/2;
        clk_sig <= '1';
        wait for clk_period/2;
    end process;

    -- テストプロセス
    stim_process: process
    begin
        input_sig <= '0';
        wait for 20 ns;

        input_sig <= '1';  -- 立ち上がりエッジ
        wait for 20 ns;
        assert rising_edge_sig = '1' report "Rising edge not detected" severity error;

        input_sig <= '0';  -- 立ち下がりエッジ
        wait for 20 ns;
        assert falling_edge_sig = '1' report "Falling edge not detected" severity error;

        wait;
    end process;
end Behavioral;

このテストベンチを実行すると、入力信号の立ち上がりと立ち下がりが正確に検出されていることが確認できます。

○サンプルコード5：ビット演算の優先順位とnot

最後に、ビット演算における優先順位とnot演算子の関係を見てみましょう。

VHDLでは、not演算子は他のビット演算子よりも優先順位が高いです。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity BitPriority is
    Port ( A, B : in STD_LOGIC_VECTOR(3 downto 0);
           result : out STD_LOGIC_VECTOR(3 downto 0));
end BitPriority;

architecture Behavioral of BitPriority is
begin
    result <= A and not B;  -- notはandよりも先に評価される
end Behavioral;

このコードでは、まずBの各ビットが反転され、その後Aとのand演算が行われます。

not演算子の優先順位が高いため、括弧を使用せずにこのような記述が可能です。

実行結果を確認してみましょう。

-- テストベンチ
entity BitPriority_TB is
end BitPriority_TB;

architecture Behavioral of BitPriority_TB is
    signal A_sig, B_sig, result_sig : STD_LOGIC_VECTOR(3 downto 0);
begin
    UUT: entity work.BitPriority port map (A => A_sig, B => B_sig, result => result_sig);

    process
    begin
        A_sig <= "1100"; B_sig <= "1010";
        wait for 10 ns;
        assert result_sig = "0100" report "Test failed for A=1100, B=1010" severity error;

        A_sig <= "1111"; B_sig <= "0101";
        wait for 10 ns;
        assert result_sig = "1010" report "Test failed for A=1111, B=0101" severity error;

        wait;
    end process;
end Behavioral;

このテストベンチを実行すると、not演算子が正しく優先的に評価され、その後and演算が行われていることが確認できます。

●VHDLアーキテクチャでのnot演算子活用法

VHDLアーキテクチャは、デジタル回路設計の核心部分です。

ここでnot演算子を適切に活用することで、効率的かつ柔軟な回路設計が可能になります。

アーキテクチャ内でnot演算子を使いこなすことは、FPGA開発エンジニアにとって必須のスキルと言えるでしょう。

○サンプルコード6：processブロックでのnot演算子使用

processブロックは、VHDLで順序回路を記述する際に重要な役割を果たします。

not演算子をprocessブロック内で使用することで、動的な論理反転が実現できます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity NotProcess is
    Port ( clk : in STD_LOGIC;
           input : in STD_LOGIC;
           output : out STD_LOGIC);
end NotProcess;

architecture Behavioral of NotProcess is
    signal internal_state : STD_LOGIC := '0';
begin
    process(clk)
    begin
        if rising_edge(clk) then
            internal_state <= not input;
        end if;
    end process;

    output <= internal_state;
end Behavioral;

このコードでは、クロックの立ち上がりエッジごとにinput信号の反転値がinternal_state信号に格納されます。

processブロック内でnot演算子を使用することで、同期的な動作が実現されています。

実行結果を確認してみましょう。

-- テストベンチ
entity NotProcess_TB is
end NotProcess_TB;

architecture Behavioral of NotProcess_TB is
    signal clk_sig, input_sig, output_sig : STD_LOGIC := '0';
    constant clk_period : time := 10 ns;
begin
    UUT: entity work.NotProcess port map (clk => clk_sig, input => input_sig, output => output_sig);

    -- クロック生成プロセス
    clk_process: process
    begin
        clk_sig <= '0';
        wait for clk_period/2;
        clk_sig <= '1';
        wait for clk_period/2;
    end process;

    -- テストプロセス
    stim_process: process
    begin
        input_sig <= '0';
        wait for 15 ns;
        assert output_sig = '1' report "Test failed for input '0'" severity error;

        input_sig <= '1';
        wait for 10 ns;
        assert output_sig = '0' report "Test failed for input '1'" severity error;

        wait;
    end process;
end Behavioral;

このテストベンチを実行すると、クロックの立ち上がりエッジごとにinput_sigの反転値がoutput_sigに出力されることが確認できます。

○サンプルコード7：generate文でのnot演算子適用

generate文は、VHDLで繰り返し構造を作成する際に非常に便利です。

not演算子とgenerate文を組み合わせることで、複数のビットに対して一括で論理反転を適用できます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity NotGenerate is
    Port ( input : in STD_LOGIC_VECTOR(7 downto 0);
           output : out STD_LOGIC_VECTOR(7 downto 0));
end NotGenerate;

architecture Behavioral of NotGenerate is
begin
    gen_not: for i in 0 to 7 generate
        output(i) <= not input(i);
    end generate gen_not;
end Behavioral;

このコードでは、generate文を使用して8ビットの入力信号の各ビットに対してnot演算を適用しています。

冗長なコードを書くことなく、効率的にビット反転を実現しています。

実行結果を確認してみましょう。

-- テストベンチ
entity NotGenerate_TB is
end NotGenerate_TB;

architecture Behavioral of NotGenerate_TB is
    signal input_sig, output_sig : STD_LOGIC_VECTOR(7 downto 0);
begin
    UUT: entity work.NotGenerate port map (input => input_sig, output => output_sig);

    process
    begin
        input_sig <= "10101010";
        wait for 10 ns;
        assert output_sig = "01010101" report "Test failed for input 10101010" severity error;

        input_sig <= "11110000";
        wait for 10 ns;
        assert output_sig = "00001111" report "Test failed for input 11110000" severity error;

        wait;
    end process;
end Behavioral;

このテストベンチを実行すると、入力信号の各ビットが正確に反転されていることが確認できます。

○サンプルコード8：信号とnot演算子の組み合わせ

VHDLでは、信号（signal）を使用してデータの流れを制御します。

not演算子と信号を組み合わせることで、複雑な論理回路を簡潔に表現できます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity NotSignal is
    Port ( clk : in STD_LOGIC;
           reset : in STD_LOGIC;
           output : out STD_LOGIC);
end NotSignal;

architecture Behavioral of NotSignal is
    signal toggle : STD_LOGIC := '0';
begin
    process(clk, reset)
    begin
        if reset = '1' then
            toggle <= '0';
        elsif rising_edge(clk) then
            toggle <= not toggle;
        end if;
    end process;

    output <= toggle;
end Behavioral;

このコードでは、toggle信号を使用してクロックの立ち上がりエッジごとに状態を反転させています。

not演算子を信号に適用することで、簡単にトグル動作を実現しています。

実行結果を確認してみましょう。

-- テストベンチ
entity NotSignal_TB is
end NotSignal_TB;

architecture Behavioral of NotSignal_TB is
    signal clk_sig, reset_sig, output_sig : STD_LOGIC := '0';
    constant clk_period : time := 10 ns;
begin
    UUT: entity work.NotSignal port map (clk => clk_sig, reset => reset_sig, output => output_sig);

    -- クロック生成プロセス
    clk_process: process
    begin
        clk_sig <= '0';
        wait for clk_period/2;
        clk_sig <= '1';
        wait for clk_period/2;
    end process;

    -- テストプロセス
    stim_process: process
    begin
        reset_sig <= '1';
        wait for 15 ns;
        reset_sig <= '0';

        wait for 10 ns;
        assert output_sig = '1' report "Test failed at first toggle" severity error;

        wait for 10 ns;
        assert output_sig = '0' report "Test failed at second toggle" severity error;

        wait;
    end process;
end Behavioral;

このテストベンチを実行すると、リセット後にクロックの立ち上がりエッジごとにoutput_sigが’0’と’1’を交互に出力することが確認できます。

●Quartusで学ぶnot演算子の実践

Quartusは、Intelが提供する強力なFPGA開発ツールです。

Quartusを使用することで、VHDLコードの合成、シミュレーション、実機へのプログラミングまで一貫して行うことができます。

not演算子の動作をQuartusで確認することで、より実践的な理解が深まります。

○サンプルコード9：Quartusでのnot演算子テスト例

Quartusでnot演算子をテストする際は、波形シミュレーションを活用すると効果的です。

次のコードは、Quartusでのシミュレーション用に最適化されています。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity QuartusNotTest is
    Port ( input : in STD_LOGIC_VECTOR(3 downto 0);
           output : out STD_LOGIC_VECTOR(3 downto 0));
end QuartusNotTest;

architecture Behavioral of QuartusNotTest is
begin
    output <= not input;
end Behavioral;

このコードをQuartusにインポートし、新しいシミュレーションを作成します。

入力信号の波形を設定し、出力信号の波形を観察することで、not演算子の動作を視覚的に確認できます。

Quartusでのシミュレーション手順を詳しく見てみましょう。

Quartusで新しいプロジェクトを作成し、上記のVHDLコードを追加します。
「Processing」メニューから「Start Compilation」を選択し、コードをコンパイルします。
「File」メニューから「New」→「University Program VWF」を選択し、新しい波形ファイルを作成します。
波形エディタで入力信号を追加し、適当な波形パターンを設定します。
「Simulation」メニューから「Run Functional Simulation」を選択し、シミュレーションを実行します。

シミュレーション結果を解析すると、入力信号が’0’の時に出力信号が’1’になり、入力信号が’1’の時に出力信号が’0’になることが確認できます。

この視覚的な確認により、not演算子の動作をより直感的に理解することができます。

○サンプルコード10：シミュレーションとデバッグ技法

Quartusでのシミュレーションとデバッグを更に深く学ぶために、より複雑な回路例を見てみましょう。

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

entity QuartusNotDebug is
    Port ( clk : in STD_LOGIC;
           reset : in STD_LOGIC;
           input : in STD_LOGIC_VECTOR(3 downto 0);
           output : out STD_LOGIC_VECTOR(3 downto 0));
end QuartusNotDebug;

architecture Behavioral of QuartusNotDebug is
    signal counter : unsigned(3 downto 0) := (others => '0');
begin
    process(clk, reset)
    begin
        if reset = '1' then
            counter <= (others => '0');
        elsif rising_edge(clk) then
            if counter = "1111" then
                counter <= (others => '0');
            else
                counter <= counter + 1;
            end if;
        end if;
    end process;

    output <= not (input xor std_logic_vector(counter));
end Behavioral;

このコードでは、4ビットのカウンタと入力信号のXOR結果を反転させて出力しています。

Quartusでこのコードをシミュレーションする際は、次の点に注意しましょう。

クロック信号とリセット信号の波形を適切に設定します。
入力信号の波形パターンを様々に変化させ、出力の変化を観察します。
カウンタの値の変化と出力信号の関係を注意深く確認します。

デバッグのコツとしては、信号の中間値を観察することが挙げられます。

例えば、counter信号の値を波形表示に追加することで、回路の内部状態を把握しやすくなります。

Quartusのシミュレーション結果を詳細に分析することで、not演算子を含む複雑な論理回路の動作を深く理解することができます。

実際の開発現場でも、このようなシミュレーションとデバッグ技法は非常に重要です。

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

VHDLプログラミングにおいて、not演算子は非常に便利な道具です。

しかし、使い方を誤ると思わぬエラーを引き起こす可能性があります。初心者エンジニアの方々は特に注意が必要です。

エラーに遭遇した際、落ち着いて対処することが大切です。

○初心者が陥りやすいnot演算子の罠

VHDLを学び始めた方々がよく陥る罠の一つに、not演算子の適用範囲の誤解があります。

例えば、複数ビットの信号全体を反転させたいのに、一部のビットにしか適用されていないケースがあります。

具体的な例を見てみましょう。

signal a: std_logic_vector(3 downto 0);
signal b: std_logic_vector(3 downto 0);

-- 誤った使用法
b <= not a(0);  -- bの最下位ビットのみが反転され、他のビットは不定になる

-- 正しい使用法
b <= not a;  -- aの全ビットが反転される

誤った使用法では、bの最下位ビットのみがaの最下位ビットの反転値となり、他のビットは不定状態になってしまいます。

正しい使用法では、aの全ビットが反転されてbに代入されます。

○エラー例と解決策

VHDLでnot演算子を使用する際、よく遭遇するエラーとその解決策をいくつか紹介します。

型の不一致エラー

signal a: integer range 0 to 255;
signal b: std_logic;

-- エラーコード
b <= not a;  -- Type mismatch error

-- 解決策
b <= not std_logic(to_unsigned(a, 8)(0));

整数型の信号にnot演算子を直接適用することはできません。

解決策として、整数を一旦std_logic_vectorに変換し、その最下位ビットをstd_logicとして取り出してから反転させます。

ビット幅の不一致エラー

signal a: std_logic_vector(7 downto 0);
signal b: std_logic_vector(3 downto 0);

-- エラーコード
b <= not a;  -- Bit width mismatch error

-- 解決策
b <= not a(3 downto 0);

ビット幅の異なる信号間での演算はエラーとなります。

解決策として、適切なビット範囲を指定してから演算を行います。

○実行時の典型的な問題と対策

実行時に発生する問題の中で、特に注意が必要なのはタイミング関連の問題です。

not演算子自体は単純ですが、複雑な回路の中で使用すると予期せぬ遅延を引き起こす可能性があります。

例えば、クリティカルパス上でnot演算子を多用すると、全体の動作周波数に影響を与える可能性があります。

-- 問題のある回路例
signal a, b, c, d, e, f: std_logic;

process(clk)
begin
    if rising_edge(clk) then
        b <= not a;
        c <= not b;
        d <= not c;
        e <= not d;
        f <= not e;
    end if;
end process;

上記の回路では、not演算子が連続して使用されており、各ステージでわずかな遅延が累積されます。

解決策として、可能な限りnot演算子の使用を最小限に抑え、必要に応じてパイプライン化を検討することが挙げられます。

-- 改善された回路例
signal a, f: std_logic;
signal b, c, d, e: std_logic;

process(clk)
begin
    if rising_edge(clk) then
        b <= not a;
        c <= b;
        d <= not c;
        e <= d;
        f <= not e;
    end if;
end process;

改善された回路では、not演算子の使用回数を減らし、中間段階でレジスタを挿入することでタイミング問題を緩和しています。

●not演算子の応用例

not演算子の基本的な使い方を理解したら、次は応用編に進みましょう。

VHDLにおいて、not演算子は単純な論理反転以上の役割を果たすことができます。

高度な条件分岐、状態機械の設計、ビット操作など、様々な場面で活躍します。

○サンプルコード11：条件分岐での高度な活用法

条件分岐においてnot演算子を効果的に使用することで、より簡潔で読みやすいコードを書くことができます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity AdvancedCondition is
    Port ( a, b, c : in STD_LOGIC;
           result : out STD_LOGIC);
end AdvancedCondition;

architecture Behavioral of AdvancedCondition is
begin
    process(a, b, c)
    begin
        if not (a = '1' and b = '1') or (c = '1') then
            result <= '1';
        else
            result <= '0';
        end if;
    end process;
end Behavioral;

このコードでは、「aとbが共に’1’でない、またはcが’1’」という複雑な条件をnot演算子を使って簡潔に表現しています。

De Morganの法則を応用することで、条件式をより理解しやすい形に変換できます。

○サンプルコード12：状態機械におけるnotの応用

状態機械の設計において、not演算子は状態遷移の条件を簡潔に表現するのに役立ちます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity StateMachine is
    Port ( clk, reset : in STD_LOGIC;
           input : in STD_LOGIC;
           output : out STD_LOGIC);
end StateMachine;

architecture Behavioral of StateMachine is
    type state_type is (S0, S1, S2);
    signal state, next_state : state_type;
begin
    process(clk, reset)
    begin
        if reset = '1' then
            state <= S0;
        elsif rising_edge(clk) then
            state <= next_state;
        end if;
    end process;

    process(state, input)
    begin
        case state is
            when S0 =>
                if not input = '1' then
                    next_state <= S1;
                else
                    next_state <= S0;
                end if;
            when S1 =>
                if input = '1' then
                    next_state <= S2;
                else
                    next_state <= S1;
                end if;
            when S2 =>
                next_state <= S0;
        end case;
    end process;

    output <= '1' when state = S2 else '0';
end Behavioral;

この状態機械では、S0からS1への遷移条件にnot演算子を使用しています。

「inputが’1’でない場合」という条件を簡潔に表現できています。

○サンプルコード13：シフト操作とnot演算子の組み合わせ

シフト操作とnot演算子を組み合わせることで、効率的なビット操作が可能になります。

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

entity ShiftNot is
    Port ( input : in STD_LOGIC_VECTOR(7 downto 0);
           output : out STD_LOGIC_VECTOR(7 downto 0));
end ShiftNot;

architecture Behavioral of ShiftNot is
begin
    process(input)
        variable temp : unsigned(7 downto 0);
    begin
        temp := unsigned(input);
        temp := shift_left(temp, 1);
        temp := not temp;
        output <= std_logic_vector(temp);
    end process;
end Behavioral;

このコードでは、入力を左に1ビットシフトした後、全ビットを反転しています。

シフト操作とnot演算子の組み合わせにより、ビット単位の複雑な操作を実現しています。

○サンプルコード14：複雑な論理回路の簡潔な表現方法

not演算子を使用することで、複雑な論理回路を簡潔に表現できます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity ComplexLogic is
    Port ( a, b, c, d : in STD_LOGIC;
           output : out STD_LOGIC);
end ComplexLogic;

architecture Behavioral of ComplexLogic is
begin
    output <= not ((a and b) or (not c and d));
end Behavioral;

このコードでは、複数の論理演算を組み合わせた複雑な条件をnot演算子を使って簡潔に表現しています。

De Morganの法則を適用することで、さらに最適化することも可能です。