====== Sequential Statements ======
===== Simultaneous Procedural Statement =====
<code vhdl>
procedural [is]
  procedural_declarative_part;
begin
  procedural_statement_part;
end procedural;
</code>

  * at the architecture
  * DAEs get worked off sequential
  * declarative_part: i. e. constants, variables, attributes, ...

{{:vhdl-ams:new_data_types:ams_daconverter.svg?nolink&300|D/A-converter}}

<code vhdl>
architecture SIMPLE of DAC is
begin
   procedural
      variable conv: real = 0.0;
   begin
      for i in digital_vek'right to digital_vek'left loop
         if digital_vek(i) = '1' then
            conv := real(2**i) + conv;
         end if;
      end loop;
      analog := conv;
   end procedural;
end architecture SIMPLE;
</code>

<callout>
=== Notes ===
Procedural statement are at the architecture body. The syntax is:
   procedural [is]
        {procedural_declarative_part};
   begin
        {sequential_statements};
   end procedural;

The procedural_declarative_part consists of constants, variables, (sub-) types, attributes... The simultaneous statements are executed sequential. Except of wait and signal assignments, all sequential statements are allowed.
</callout>

===== Break =====
{{:vhdl-ams:new_data_types:ams_breaklist.svg?nolink&500|Break List}}

<code vhdl>
    q == C * v;
    i == q'Dot;
break for q use v => init when init/= real'low;

    i == C * v'Dot:
break v => init when init/= real'low;
</code>

  * discontinuity of a DAE => reset of the quantity is essential
  * break_element: quantity has the same type as the expression
  * selector_clause: quantity must be of the form Q'Dot or Q'Integ
  * without conditions: quantities get initialized for simulation start time

<code vhdl>
break a => 0.0;

break x => 1.5, y => 0.0, z => 20;
</code>

<callout>
=== Notes ===
One of the most important new data types is break. It announces a discontinuity in the solution of a DAE. To go on after a discontinuity, the quantities get re - initialized for the next continuous interval. The break follows after an event on a signal or when some condition becomes true. The syntax is:
   break [break_list] [when condition];
   break_list ::= break_element(s)
   break_element ::= [selector_clause] {quantity_name} => {expression}
   selector_clause ::= for {quantity_name} use

Exist a condition for the break, the break is sensitive on it. Exists no condition, the quantities of the break get initialized for the simulation start. The selector clause quantity is the quantity the discontinuity may be. It must be of the type Q'Dot or Q'Integ. Exists no selector clause, it counts for the quantities of the break_element(s), too. The type of the expression must be of the same type like the initializing quantity.
</callout>