URL
https://opencores.org/ocsvn/yac/yac/trunk
Subversion Repositories yac
Compare Revisions
- This comparison shows the changes necessary to convert path
/yac
- from Rev 1 to Rev 2
- ↔ Reverse comparison
Rev 1 → Rev 2
/trunk/rtl/vhdl/cordic_iterative_pkg.vhd
0,0 → 1,3068
---------------------------------------------------------------------------- |
---- ---- |
---- File : cordic_iterative_pkg.vhd ---- |
---- Project : YAC (Yet Another CORDIC Core) ---- |
---- Creation : Feb. 2014 ---- |
---- Limitations : ---- |
---- Synthesizer : ---- |
---- Target : ---- |
---- ---- |
---- Author(s): : Christian Haettich ---- |
---- Email : feddischson@opencores.org ---- |
---- ---- |
---- ---- |
----- ----- |
---- ---- |
---- Description ---- |
---- VHDL Package which contains some flabs and ---- |
---- some auto-generated division (multiplication) ---- |
---- functions. ---- |
---- ---- |
---- ---- |
---- ---- |
----- ----- |
---- ---- |
---- TODO ---- |
---- Some documentation ---- |
---- ---- |
---- ---- |
---- ---- |
---- ---- |
---------------------------------------------------------------------------- |
---- ---- |
---- Copyright Notice ---- |
---- ---- |
---- This file is part of YAC - Yet Another CORDIC Core ---- |
---- Copyright (c) 2014, Author(s), All rights reserved. ---- |
---- ---- |
---- YAC is free software; you can redistribute it and/or ---- |
---- modify it under the terms of the GNU Lesser General Public ---- |
---- License as published by the Free Software Foundation; either ---- |
---- version 3.0 of the License, or (at your option) any later version. ---- |
---- ---- |
---- YAC is distributed in the hope that it will be useful, ---- |
---- but WITHOUT ANY WARRANTY; without even the implied warranty of ---- |
---- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ---- |
---- Lesser General Public License for more details. ---- |
---- ---- |
---- You should have received a copy of the GNU Lesser General Public ---- |
---- License along with this library. If not, download it from ---- |
---- http://www.gnu.org/licenses/lgpl ---- |
---- ---- |
---------------------------------------------------------------------------- |
|
|
|
library ieee; |
use ieee.std_logic_1164.ALL; |
use ieee.numeric_std.ALL; |
|
package cordic_pkg is |
|
|
|
constant I_FLAG_VEC_ROT : natural := 3; -- bit index |
constant I_FLAG_ATAN_3 : natural := 2; -- bit index (for future usage) |
constant VAL_MODE_CIR : std_logic_vector( 1 downto 0 ) := "00"; -- value |
constant VAL_MODE_LIN : std_logic_vector( 1 downto 0 ) := "01"; -- value |
constant VAL_MODE_HYP : std_logic_vector( 1 downto 0 ) := "10"; -- value |
|
procedure mult_0_61( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural; |
constant RM_GAIN : in natural ); |
|
procedure mult_0_21( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural; |
constant RM_GAIN : in natural ); |
|
|
|
end package cordic_pkg; |
|
|
package body cordic_pkg is |
|
|
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_01( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_01; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_02( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 4 ); |
when 2 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_02; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_03( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 3 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_03; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_04( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_04; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_05( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 12 ); |
when 5 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_05; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_06( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_06; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_07( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_07; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_08( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 19 ); |
when 8 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_08; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_09( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 22 ); |
when 9 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_09; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_10( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 25 ); |
when 10 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_10; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_11( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 11 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_11; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_12( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_12; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_13( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_13; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_14( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 39 ); |
when 14 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_14; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_15( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 15 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_15; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_16( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_16; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_17( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_17; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_18( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_18; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_19( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_19; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_20( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_20; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_21( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_21; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_22( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_22; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_23( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 23 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_23; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_24( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 23 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 24 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_24; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_25( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 23 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 24 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 25 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_25; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_26( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 23 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 24 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 25 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 26 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_26; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_27( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 23 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 24 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 25 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 26 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 27 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_27; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_28( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 23 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 24 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 25 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 26 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 27 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 65 ); |
when 28 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_28; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_29( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 23 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 24 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 25 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 26 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 27 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 65 ); |
when 28 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 66 ); |
when 29 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_29; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61_30( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= to_signed( 0, sum'length ); |
a_sh <= SHIFT_RIGHT( a, 1 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 2 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 9 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 13 ); |
when 5 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 14 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 7 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 20 ); |
when 8 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 23 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 26 ); |
when 10 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 28 ); |
when 11 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 29 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 34 ); |
when 13 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 38 ); |
when 14 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 41 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 17 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 18 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 56 ); |
when 19 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 20 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 21 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 22 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 23 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 24 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 25 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 26 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 27 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 65 ); |
when 28 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 66 ); |
when 29 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 67 ); |
when 30 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_61_30; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.607253 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_61( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural; |
constant RM_GAIN : in natural ) is |
begin |
case RM_GAIN is |
when 1 => mult_0_61_01( a, a_sh, sum, cnt ); |
when 2 => mult_0_61_02( a, a_sh, sum, cnt ); |
when 3 => mult_0_61_03( a, a_sh, sum, cnt ); |
when 4 => mult_0_61_04( a, a_sh, sum, cnt ); |
when 5 => mult_0_61_05( a, a_sh, sum, cnt ); |
when 6 => mult_0_61_06( a, a_sh, sum, cnt ); |
when 7 => mult_0_61_07( a, a_sh, sum, cnt ); |
when 8 => mult_0_61_08( a, a_sh, sum, cnt ); |
when 9 => mult_0_61_09( a, a_sh, sum, cnt ); |
when 10 => mult_0_61_10( a, a_sh, sum, cnt ); |
when 11 => mult_0_61_11( a, a_sh, sum, cnt ); |
when 12 => mult_0_61_12( a, a_sh, sum, cnt ); |
when 13 => mult_0_61_13( a, a_sh, sum, cnt ); |
when 14 => mult_0_61_14( a, a_sh, sum, cnt ); |
when 15 => mult_0_61_15( a, a_sh, sum, cnt ); |
when 16 => mult_0_61_16( a, a_sh, sum, cnt ); |
when 17 => mult_0_61_17( a, a_sh, sum, cnt ); |
when 18 => mult_0_61_18( a, a_sh, sum, cnt ); |
when 19 => mult_0_61_19( a, a_sh, sum, cnt ); |
when 20 => mult_0_61_20( a, a_sh, sum, cnt ); |
when 21 => mult_0_61_21( a, a_sh, sum, cnt ); |
when 22 => mult_0_61_22( a, a_sh, sum, cnt ); |
when 23 => mult_0_61_23( a, a_sh, sum, cnt ); |
when 24 => mult_0_61_24( a, a_sh, sum, cnt ); |
when 25 => mult_0_61_25( a, a_sh, sum, cnt ); |
when 26 => mult_0_61_26( a, a_sh, sum, cnt ); |
when 27 => mult_0_61_27( a, a_sh, sum, cnt ); |
when 28 => mult_0_61_28( a, a_sh, sum, cnt ); |
when 29 => mult_0_61_29( a, a_sh, sum, cnt ); |
when 30 => mult_0_61_30( a, a_sh, sum, cnt ); |
when others => mult_0_61_30( a, a_sh, sum, cnt ); |
end case; |
end procedure mult_0_61; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_01( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 3 ); |
when 1 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_01; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_02( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 4 ); |
when 2 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_02; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_03( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 6 ); |
when 3 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_03; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_04( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_04; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_05( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 12 ); |
when 5 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_05; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_06( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 15 ); |
when 6 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_06; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_07( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_07; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_08( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 22 ); |
when 8 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_08; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_09( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_09; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_10( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_10; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_11( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 37 ); |
when 11 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_11; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_12( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 39 ); |
when 12 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_12; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_13( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 42 ); |
when 13 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_13; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_14( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 44 ); |
when 14 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_14; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_15( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 50 ); |
when 15 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_15; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_16( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 52 ); |
when 16 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_16; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_17( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_17; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_18( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_18; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_19( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_19; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_20( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_20; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_21( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_21; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_22( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_22; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_23( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 23 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_23; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_24( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 23 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 24 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_24; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_25( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 23 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 24 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 25 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_25; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_26( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 23 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 24 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 25 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 65 ); |
when 26 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_26; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_27( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 23 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 24 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 25 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 65 ); |
when 26 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 66 ); |
when 27 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_27; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_28( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 23 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 24 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 25 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 65 ); |
when 26 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 66 ); |
when 27 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 67 ); |
when 28 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_28; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_29( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 23 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 24 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 25 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 65 ); |
when 26 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 66 ); |
when 27 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 67 ); |
when 28 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 68 ); |
when 29 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_29; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21_30( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural ) is |
begin |
case cnt is |
when 0 => sum <= a; |
a_sh <= SHIFT_RIGHT( a, 2 ); |
when 1 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 5 ); |
when 2 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 7 ); |
when 3 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 8 ); |
when 4 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 11 ); |
when 5 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 16 ); |
when 6 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 17 ); |
when 7 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 21 ); |
when 8 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 24 ); |
when 9 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 27 ); |
when 10 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 36 ); |
when 11 => sum <= sum + a_sh; |
a_sh <= SHIFT_RIGHT( a, 40 ); |
when 12 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 43 ); |
when 13 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 45 ); |
when 14 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 51 ); |
when 15 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 53 ); |
when 16 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 55 ); |
when 17 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 57 ); |
when 18 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 58 ); |
when 19 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 59 ); |
when 20 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 60 ); |
when 21 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 61 ); |
when 22 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 62 ); |
when 23 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 63 ); |
when 24 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 64 ); |
when 25 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 65 ); |
when 26 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 66 ); |
when 27 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 67 ); |
when 28 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 68 ); |
when 29 => sum <= sum - a_sh; |
a_sh <= SHIFT_RIGHT( a, 69 ); |
when 30 => sum <= sum - a_sh; |
when others => sum <= sum; |
end case; |
end procedure mult_0_21_30; |
|
|
-- |
-- Auto-generated procedure to multiply "a" with 0.207497 iteratively |
-- a_sh is a temporary register to store the shifted value, and |
-- sum is a temporary register to sum up the result |
-- |
procedure mult_0_21( signal a : in signed; |
signal a_sh : inout signed; |
signal sum : inout signed; |
cnt : in natural; |
constant RM_GAIN : in natural ) is |
begin |
case RM_GAIN is |
when 1 => mult_0_21_01( a, a_sh, sum, cnt ); |
when 2 => mult_0_21_02( a, a_sh, sum, cnt ); |
when 3 => mult_0_21_03( a, a_sh, sum, cnt ); |
when 4 => mult_0_21_04( a, a_sh, sum, cnt ); |
when 5 => mult_0_21_05( a, a_sh, sum, cnt ); |
when 6 => mult_0_21_06( a, a_sh, sum, cnt ); |
when 7 => mult_0_21_07( a, a_sh, sum, cnt ); |
when 8 => mult_0_21_08( a, a_sh, sum, cnt ); |
when 9 => mult_0_21_09( a, a_sh, sum, cnt ); |
when 10 => mult_0_21_10( a, a_sh, sum, cnt ); |
when 11 => mult_0_21_11( a, a_sh, sum, cnt ); |
when 12 => mult_0_21_12( a, a_sh, sum, cnt ); |
when 13 => mult_0_21_13( a, a_sh, sum, cnt ); |
when 14 => mult_0_21_14( a, a_sh, sum, cnt ); |
when 15 => mult_0_21_15( a, a_sh, sum, cnt ); |
when 16 => mult_0_21_16( a, a_sh, sum, cnt ); |
when 17 => mult_0_21_17( a, a_sh, sum, cnt ); |
when 18 => mult_0_21_18( a, a_sh, sum, cnt ); |
when 19 => mult_0_21_19( a, a_sh, sum, cnt ); |
when 20 => mult_0_21_20( a, a_sh, sum, cnt ); |
when 21 => mult_0_21_21( a, a_sh, sum, cnt ); |
when 22 => mult_0_21_22( a, a_sh, sum, cnt ); |
when 23 => mult_0_21_23( a, a_sh, sum, cnt ); |
when 24 => mult_0_21_24( a, a_sh, sum, cnt ); |
when 25 => mult_0_21_25( a, a_sh, sum, cnt ); |
when 26 => mult_0_21_26( a, a_sh, sum, cnt ); |
when 27 => mult_0_21_27( a, a_sh, sum, cnt ); |
when 28 => mult_0_21_28( a, a_sh, sum, cnt ); |
when 29 => mult_0_21_29( a, a_sh, sum, cnt ); |
when 30 => mult_0_21_30( a, a_sh, sum, cnt ); |
when others => mult_0_21_30( a, a_sh, sum, cnt ); |
end case; |
end procedure mult_0_21; |
|
|
|
|
end cordic_pkg; |
/trunk/rtl/vhdl/cordic_iterative_tb.vhd
0,0 → 1,294
---------------------------------------------------------------------------- |
---- ---- |
---- File : cordic_iterative_tb.vhd ---- |
---- Project : YAC (Yet Another CORDIC Core) ---- |
---- Creation : Feb. 2014 ---- |
---- Limitations : ---- |
---- Synthesizer : ---- |
---- Target : ---- |
---- ---- |
---- Author(s): : Christian Haettich ---- |
---- Email : feddischson@opencores.org ---- |
---- ---- |
---- ---- |
----- ----- |
---- ---- |
---- Description ---- |
---- VHDL Testbench ---- |
---- ---- |
---- ---- |
---- ---- |
----- ----- |
---- ---- |
---- TODO ---- |
---- Some documentation ---- |
---- ---- |
---- ---- |
---- ---- |
---- ---- |
---------------------------------------------------------------------------- |
---- ---- |
---- Copyright Notice ---- |
---- ---- |
---- This file is part of YAC - Yet Another CORDIC Core ---- |
---- Copyright (c) 2014, Author(s), All rights reserved. ---- |
---- ---- |
---- YAC is free software; you can redistribute it and/or ---- |
---- modify it under the terms of the GNU Lesser General Public ---- |
---- License as published by the Free Software Foundation; either ---- |
---- version 3.0 of the License, or (at your option) any later version. ---- |
---- ---- |
---- YAC is distributed in the hope that it will be useful, ---- |
---- but WITHOUT ANY WARRANTY; without even the implied warranty of ---- |
---- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ---- |
---- Lesser General Public License for more details. ---- |
---- ---- |
---- You should have received a copy of the GNU Lesser General Public ---- |
---- License along with this library. If not, download it from ---- |
---- http://www.gnu.org/licenses/lgpl ---- |
---- ---- |
---------------------------------------------------------------------------- |
|
|
|
LIBRARY ieee; |
USE ieee.std_logic_1164.ALL; |
use ieee.numeric_std.ALL; |
|
library std; |
use std.textio.all; -- for reading/writing from/to files |
use std.env.all; -- for finish() |
|
library work; |
|
|
entity cordic_iterative_tb is |
|
end entity cordic_iterative_tb; |
|
|
architecture IMP of cordic_iterative_tb is |
|
|
constant FRQ_MULT_VALUE : integer :=18; |
|
constant stim_file : string := "../../c_octave/tb_data.txt"; |
constant err_file : string := "./error_out.txt"; |
|
constant clk_T : time := 5 ns; |
signal clk : std_logic; |
signal rst : std_logic; |
signal nrst : std_logic; |
|
constant XY_WIDTH : natural := 25; |
constant A_WIDTH : natural := 25; |
constant GUARD_BITS : natural := 2; |
constant RM_GAIN : natural := 5; |
component cordic_iterative_int is |
generic( |
XY_WIDTH : natural := 12; |
A_WIDTH : natural := 12; |
GUARD_BITS : natural := 2; |
RM_GAIN : natural := 4 |
); |
port( |
clk, rst : in std_logic; |
en : in std_logic; |
start : in std_logic; |
done : out std_logic; |
mode_i : in std_logic_vector( 4-1 downto 0 ); |
x_i : in std_logic_vector( XY_WIDTH-1 downto 0 ); |
y_i : in std_logic_vector( XY_WIDTH-1 downto 0 ); |
a_i : in std_logic_vector( A_WIDTH+2-1 downto 0 ); |
x_o : out std_logic_vector( XY_WIDTH+GUARD_BITS-1 downto 0 ); |
y_o : out std_logic_vector( XY_WIDTH+GUARD_BITS-1 downto 0 ); |
a_o : out std_logic_vector( A_WIDTH+2-1 downto 0 ) |
); |
end component cordic_iterative_int; |
signal en : std_logic; |
signal start : std_logic; |
signal done : std_logic; |
signal mode_i : std_logic_vector( 4-1 downto 0 ); |
signal x_i : std_logic_vector( XY_WIDTH-1 downto 0 ); |
signal y_i : std_logic_vector( XY_WIDTH-1 downto 0 ); |
signal a_i : std_logic_vector( A_WIDTH+2-1 downto 0 ); |
signal x_o : std_logic_vector( XY_WIDTH+GUARD_BITS-1 downto 0 ); |
signal y_o : std_logic_vector( XY_WIDTH+GUARD_BITS-1 downto 0 ); |
signal a_o : std_logic_vector( A_WIDTH+2-1 downto 0 ); |
|
|
|
begin |
|
|
-- -- |
-- clock and reset |
-- |
nrst <= not rst; |
clk_gen : process |
begin |
clk <= '1'; |
wait for clk_T/2; |
clk <= '0'; |
wait for clk_T/2; |
end process; |
rst_gen : process |
begin |
rst <= '1'; |
wait for clk_T * 10; |
rst <= '0'; |
wait; |
end process; |
|
|
|
|
dut : cordic_iterative_int |
generic map ( |
XY_WIDTH => XY_WIDTH , |
A_WIDTH => A_WIDTH , |
GUARD_BITS => GUARD_BITS, |
RM_GAIN => RM_GAIN |
) |
port map( |
clk => clk , |
rst => rst , |
en => en , |
start => start , |
done => done , |
mode_i => mode_i , |
x_i => x_i , |
y_i => y_i , |
a_i => a_i , |
x_o => x_o , |
y_o => y_o , |
a_o => a_o |
); |
|
|
|
-- |
-- |
-- |
stims_p : process |
|
file test_pattern_file : text; |
file error_pattern_file : text; |
variable file_status : file_open_status; |
variable input_line : line; |
variable input_line_bak : line; |
variable good : boolean; |
|
type values_t is array ( 0 to 7 ) of integer; |
variable tmp_value : values_t; |
|
variable x_ex : std_logic_vector( x_o'range ); |
variable y_ex : std_logic_vector( y_o'range ); |
variable a_ex : std_logic_vector( a_o'range ); |
variable err_cnt : integer := 0; |
variable stim_cnt : integer := 0; |
begin |
|
err_cnt := 0; |
|
-- |
-- open file |
-- |
file_open( file_status, test_pattern_file, stim_file, READ_MODE ); |
if file_status /= open_ok then |
report "unable to open input stimulation file, please use cordic_iterative_test.m to create stimulation file" severity error; |
stop( -1 ); |
end if; |
file_open( file_status, error_pattern_file, err_file, WRITE_MODE ); |
if file_status /= open_ok then |
report "unable to open output error file" severity error; |
stop( -1 ); |
end if; |
|
-- wait some cycles |
x_i <= ( others => '0' ); |
y_i <= ( others => '0' ); |
a_i <= ( others => '0' ); |
mode_i <= ( others => '0' ); |
start <= '0'; |
wait for clk_T * 20; |
|
wait until clk'event and clk='1'; |
|
while ( not endfile( test_pattern_file ) )loop |
|
|
wait until en='1'; |
wait for clk_T; |
|
|
-- read line and extract values |
readline( test_pattern_file, input_line ); |
input_line_bak := new string'( input_line.ALL ); |
for i in 0 to 6 loop |
read( input_line, tmp_value(i), good ); |
--report "rd: "& integer'image( i ) & " : " & integer'image( tmp_value( i ) ); |
end loop; |
|
-- assign values to DUT |
x_i <= std_logic_vector( to_signed ( tmp_value(0), x_i'length ) ); |
y_i <= std_logic_vector( to_signed ( tmp_value(1), y_i'length ) ); |
a_i <= std_logic_vector( to_signed ( tmp_value(2), a_i'length ) ); |
x_ex := std_logic_vector( to_signed ( tmp_value(3), x_ex'length ) ); |
y_ex := std_logic_vector( to_signed ( tmp_value(4), y_ex'length ) ); |
a_ex := std_logic_vector( to_signed ( tmp_value(5), a_ex'length ) ); |
mode_i <= std_logic_vector( to_unsigned( tmp_value(6), mode_i'length ) ); |
-- start the DUT and wait, until the DUT is done |
start <= '1'; |
wait for clk_T; |
start <= '0'; |
|
wait until done = '1'; |
wait until clk'event and clk='1'; |
stim_cnt := stim_cnt+1; |
|
if x_ex /= x_o or |
y_ex /= y_o or |
a_ex /= a_o then |
assert x_ex = x_o report |
integer'image( stim_cnt ) & ": Serial Cordic Failed: expected x result:" |
& integer'image( tmp_value(5) ) & ", but got:" |
& integer'image( to_integer( signed( x_ex ) ) ); |
assert y_ex = y_o report |
integer'image( stim_cnt ) & ": Serial Cordic Failed: expected y result:" |
& integer'image( tmp_value(6) ) & ", but got:" |
& integer'image( to_integer( signed( y_ex ) ) ); |
assert a_ex = a_o report |
integer'image( stim_cnt ) & ": Serial Cordic Failed: expected a result:" |
& integer'image( tmp_value(7) ) & ", but got:" |
& integer'image( to_integer( signed( a_ex ) ) ); |
err_cnt := err_cnt + 1; |
writeline( error_pattern_file, input_line_bak ); |
|
end if; |
|
wait for CLK_T * 5; |
|
end loop; |
report "====>>>> Serial Cordic Verification Result:" & integer'image( err_cnt ) & " of " & integer'image( stim_cnt ) & " tests failed"; |
stop( 0 ); |
end process stims_p; |
|
|
|
|
en_test : process |
begin |
en <= '0'; |
wait for clk_T * 10; |
en <= '1'; |
wait for clk_T * 1000; |
|
end process; |
|
|
end architecture IMP; |
|
|
|
|
/trunk/rtl/vhdl/cordic_iterative_int.vhd
0,0 → 1,514
---------------------------------------------------------------------------- |
---- ---- |
---- File : cordic_iterative_int.vhd ---- |
---- Project : YAC (Yet Another CORDIC Core) ---- |
---- Creation : Feb. 2014 ---- |
---- Limitations : ---- |
---- Synthesizer : ---- |
---- Target : ---- |
---- ---- |
---- Author(s): : Christian Haettich ---- |
---- Email : feddischson@opencores.org ---- |
---- ---- |
---- ---- |
----- ----- |
---- ---- |
---- Description ---- |
---- VHDL implementation of YAC ---- |
---- ---- |
---- ---- |
---- ---- |
----- ----- |
---- ---- |
---- TODO ---- |
---- Some documentation and function description ---- |
---- Optimization ---- |
---- ---- |
---- ---- |
---- ---- |
---------------------------------------------------------------------------- |
---- ---- |
---- Copyright Notice ---- |
---- ---- |
---- This file is part of YAC - Yet Another CORDIC Core ---- |
---- Copyright (c) 2014, Author(s), All rights reserved. ---- |
---- ---- |
---- YAC is free software; you can redistribute it and/or ---- |
---- modify it under the terms of the GNU Lesser General Public ---- |
---- License as published by the Free Software Foundation; either ---- |
---- version 3.0 of the License, or (at your option) any later version. ---- |
---- ---- |
---- YAC is distributed in the hope that it will be useful, ---- |
---- but WITHOUT ANY WARRANTY; without even the implied warranty of ---- |
---- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ---- |
---- Lesser General Public License for more details. ---- |
---- ---- |
---- You should have received a copy of the GNU Lesser General Public ---- |
---- License along with this library. If not, download it from ---- |
---- http://www.gnu.org/licenses/lgpl ---- |
---- ---- |
---------------------------------------------------------------------------- |
|
|
|
library ieee; |
library std; |
use std.textio.all; |
use ieee.std_logic_1164.ALL; |
use ieee.numeric_std.ALL; |
use ieee.std_logic_textio.all; -- I/O for logic types |
use work.cordic_pkg.ALL; |
use ieee.math_real.ALL; |
|
entity cordic_iterative_int is |
generic( |
XY_WIDTH : natural := 12; |
A_WIDTH : natural := 12; |
GUARD_BITS : natural := 2; |
RM_GAIN : natural := 4 |
); |
port( |
clk, rst : in std_logic; |
en : in std_logic; |
start : in std_logic; |
done : out std_logic; |
mode_i : in std_logic_vector( 4-1 downto 0 ); |
x_i : in std_logic_vector( XY_WIDTH-1 downto 0 ); |
y_i : in std_logic_vector( XY_WIDTH-1 downto 0 ); |
a_i : in std_logic_vector( A_WIDTH+2-1 downto 0 ); |
x_o : out std_logic_vector( XY_WIDTH+GUARD_BITS-1 downto 0 ); |
y_o : out std_logic_vector( XY_WIDTH+GUARD_BITS-1 downto 0 ); |
a_o : out std_logic_vector( A_WIDTH+2-1 downto 0 ) |
); |
end entity cordic_iterative_int; |
|
|
architecture BEHAVIORAL of cordic_iterative_int is |
|
-- log2( max-iteration ) |
constant L2_MAX_I : natural := 8; |
|
constant MAX_A_WIDTH : natural := 34; |
|
-- Internal angle width |
constant A_WIDTH_I : natural := A_WIDTH+2; |
|
|
constant SQRT2_REAL : real := 1.4142135623730951454746218587388284504413604; |
constant PI_REAL : real := 3.1415926535897931159979634685441851615905762; |
constant PI : integer := natural( PI_REAL * real( 2**( A_WIDTH-1 ) ) + 0.5 ); |
constant PI_H : integer := natural( PI_REAL * real( 2**( A_WIDTH-2 ) ) + 0.5 ); |
constant SQRT2 : integer := natural( SQRT2_REAL * real( 2**( XY_WIDTH-1 ) ) + 0.5 ); |
constant XY_MAX : integer := natural( 2**( XY_WIDTH-1)-1); |
|
|
constant XY_WIDTH_G : natural := XY_WIDTH + GUARD_BITS; |
|
|
|
type state_st is( ST_IDLE, ST_INIT, ST_ROTATE, ST_RM_GAIN, ST_DONE ); |
type state_t is record |
st : state_st; |
mode : std_logic_vector( mode_i'range ); |
x : signed( XY_WIDTH_G -1 downto 0 ); |
y : signed( XY_WIDTH_G -1 downto 0 ); |
x_sh : signed( XY_WIDTH_G -1 downto 0 ); |
y_sh : signed( XY_WIDTH_G -1 downto 0 ); |
x_sum : signed( XY_WIDTH_G -1 downto 0 ); |
y_sum : signed( XY_WIDTH_G -1 downto 0 ); |
a : signed( A_WIDTH_I -1 downto 0 ); |
a_tmp : signed( A_WIDTH_I -1 downto 0 ); |
ylst : signed( XY_WIDTH_G -1 downto 0 ); |
alst : signed( A_WIDTH_I -1 downto 0 ); |
i : signed( L2_MAX_I -1 downto 0 ); |
do_shift : std_logic; |
done : std_logic; |
repeate : std_logic; |
end record state_t; |
signal state : state_t; |
|
|
--------------------------------------- |
-- Auto-generated function |
-- by matlab (see c_octave/cordic_iterative_code.m) |
function angular_lut( n : integer; mode : std_logic_vector; ANG_WIDTH : natural ) return signed is |
variable result : signed( ANG_WIDTH-1 downto 0 ); |
variable temp : signed( MAX_A_WIDTH-1 downto 0 ); |
begin |
if mode = VAL_MODE_CIR then |
case n is |
when 0 => temp := "0110010010000111111011010101000100"; -- -1843415740 |
when 1 => temp := "0011101101011000110011100000101011"; -- -312264661 |
when 2 => temp := "0001111101011011011101011111100100"; -- 2104350692 |
when 3 => temp := "0000111111101010110111010100110101"; -- 1068201269 |
when 4 => temp := "0000011111111101010101101110110111"; -- 536173495 |
when 5 => temp := "0000001111111111101010101011011101"; -- 268348125 |
when 6 => temp := "0000000111111111111101010101010110"; -- 134206806 |
when 7 => temp := "0000000011111111111111101010101010"; -- 67107498 |
when 8 => temp := "0000000001111111111111111101010101"; -- 33554261 |
when 9 => temp := "0000000000111111111111111111101010"; -- 16777194 |
when 10 => temp := "0000000000011111111111111111111101"; -- 8388605 |
when others => temp := to_signed( 2**(MAX_A_WIDTH-1-n), MAX_A_WIDTH ); |
end case; |
elsif mode = VAL_MODE_HYP then |
case n is |
when 1 => temp := "0100011001001111101010011110101010"; -- 423536554 |
when 2 => temp := "0010000010110001010111011111010100"; -- -2100987948 |
when 3 => temp := "0001000000010101100010010001110010"; -- 1079387250 |
when 4 => temp := "0000100000000010101011000100010101"; -- 537571605 |
when 5 => temp := "0000010000000000010101010110001000"; -- 268522888 |
when 6 => temp := "0000001000000000000010101010101100"; -- 134228652 |
when 7 => temp := "0000000100000000000000010101010101"; -- 67110229 |
when 8 => temp := "0000000010000000000000000010101010"; -- 33554602 |
when 9 => temp := "0000000001000000000000000000010101"; -- 16777237 |
when 10 => temp := "0000000000100000000000000000000010"; -- 8388610 |
when others => temp := to_signed( 2**(MAX_A_WIDTH-1-n), MAX_A_WIDTH ); |
end case; |
elsif mode = VAL_MODE_LIN then |
temp := ( others => '0' ); |
temp( temp'high-1-n downto 0 ) := ( others => '1' ); |
end if; |
result := temp( temp'high downto temp'high-result'length+1 ); |
return result; |
end function angular_lut; |
--------------------------------------- |
|
|
function repeat_hyperbolic_it( i : integer ) return boolean is |
variable res : boolean; |
begin |
case i is |
when 5 => res := true; |
when 14 => res := true; |
when 41 => res := true; |
when 122 => res := true; |
when others => res := false; |
end case; |
return res; |
end; |
|
begin |
|
|
ST : process( clk, rst ) |
variable sign : std_logic; |
begin |
|
if clk'event and clk = '1' then |
if rst = '1' then |
state <= ( st => ST_IDLE, |
x => ( others => '0' ), |
y => ( others => '0' ), |
x_sh => ( others => '0' ), |
y_sh => ( others => '0' ), |
x_sum => ( others => '0' ), |
y_sum => ( others => '0' ), |
a => ( others => '0' ), |
a_tmp => ( others => '0' ), |
ylst => ( others => '0' ), |
alst => ( others => '0' ), |
mode => ( others => '0' ), |
i => ( others => '0' ), |
done => '0', |
do_shift => '0', |
repeate => '0' |
); |
|
elsif en = '1' then |
|
if state.st = ST_IDLE and start = '1' then |
state.st <= ST_INIT; |
state.mode <= mode_i; |
state.x <= resize( signed( x_i ), state.x'length ); |
state.y <= resize( signed( y_i ), state.y'length ); |
state.a <= resize( signed( a_i ), state.a'length ); |
state.i <= ( others => '0' ); |
|
elsif state.st = ST_INIT then |
-- |
-- initialization state |
-- -> do initial rotation (alignment) |
-- -> check special situations / miss-configurations (TODO) |
-- |
|
state.st <= ST_ROTATE; |
state.do_shift <= '1'; |
|
|
if state.mode( 1 downto 0 ) = VAL_MODE_HYP then |
-- if we do a hyperbolic rotation, we start with 1 |
state.i(0) <= '1'; |
end if; |
|
|
|
|
if state.mode( I_FLAG_VEC_ROT ) = '0' |
and state.mode( 1 downto 0 ) = VAL_MODE_CIR then |
-- circular vector mode |
|
if state.a < - PI_H then |
-- move from third quadrant to first |
state.a <= state.a + PI; |
state.x <= - state.x; |
state.y <= - state.y; |
elsif state.a > PI_H then |
-- move from second quadrant to fourth |
state.a <= state.a - PI; |
state.x <= - state.x; |
state.y <= - state.y; |
end if; |
|
elsif state.mode( I_FLAG_VEC_ROT ) = '1' |
and state.mode( 1 downto 0 ) = VAL_MODE_CIR then |
-- circular rotation mode |
|
if state.x = 0 and state.y = 0 then |
-- zero-input |
state.a <= ( others => '0' ); |
state.y <= ( others => '0' ); |
state.st <= ST_DONE; |
|
elsif state.x = XY_MAX and state.y = XY_MAX then |
-- all-max 1 |
state.a <= resize( angular_lut( 0, state.mode( 1 downto 0 ), A_WIDTH ), A_WIDTH_I ); |
state.x <= to_signed( SQRT2, state.x'length ); |
state.y <= (others => '0' ); |
state.st <= ST_DONE; |
elsif state.x = -XY_MAX and state.y = -XY_MAX then |
-- all-max 2 |
state.a <= resize( angular_lut( 0, state.mode( 1 downto 0 ), A_WIDTH ), A_WIDTH_I ) - PI; |
state.x <= to_signed( SQRT2, state.x'length ); |
state.y <= (others => '0' ); |
state.st <= ST_DONE; |
elsif state.x = XY_MAX and state.y = -XY_MAX then |
-- all-max 3 |
state.a <= resize( -angular_lut( 0, state.mode( 1 downto 0 ), A_WIDTH ), A_WIDTH_I ); |
state.x <= to_signed( SQRT2, state.x'length ); |
state.y <= (others => '0' ); |
state.st <= ST_DONE; |
elsif state.x = -XY_MAX and state.y = XY_MAX then |
-- all-max 4 |
state.a <= PI- resize( angular_lut( 0, state.mode( 1 downto 0 ), A_WIDTH ), A_WIDTH_I ); |
state.x <= to_signed( SQRT2, state.x'length ); |
state.y <= (others => '0' ); |
state.st <= ST_DONE; |
|
elsif state.x = 0 and state.y > 0 then |
-- fixed rotation of pi/2 |
state.a <= to_signed( PI_H, state.a'length ); |
state.x <= state.y; |
state.y <= ( others => '0' ); |
state.st<= ST_DONE; |
elsif state.x = 0 and state.y < 0 then |
-- fixed rotation of -pi/2 |
state.a <= to_signed( -PI_H, state.a'length ); |
state.x <= -state.y; |
state.y <= ( others => '0' ); |
state.st<= ST_DONE; |
|
elsif state.x < 0 and state.y >= 0 then |
-- move from second quadrant to fourth |
state.x <= - state.x; |
state.y <= - state.y; |
state.a <= to_signed( PI, state.a'length ); |
elsif state.x < 0 and state.y < 0 then |
-- move from third quadrant to first |
state.x <= - state.x; |
state.y <= - state.y; |
state.a <= to_signed( -PI, state.a'length ); |
else |
state.a <= ( others => '0' ); |
end if; |
elsif state.mode( I_FLAG_VEC_ROT ) = '1' |
and state.mode( 1 downto 0 ) = VAL_MODE_LIN then |
-- linear rotation mode |
if state.x < 0 then |
state.x <= - state.x; |
state.y <= - state.y; |
end if; |
state.a <= to_signed( 0, state.a'length ); |
|
end if; |
|
|
|
|
|
-- |
-- rotation state |
-- |
-- Each rotation takes |
-- two steps: in the first step, the shifting is |
-- done, in the second step, the |
-- shift-result is added/subtracted |
-- |
-- |
-- |
elsif state.st = ST_ROTATE then |
|
-- get the sign |
if state.mode( I_FLAG_VEC_ROT ) = '0' then |
if state.a < 0 then |
sign := '0'; |
else |
sign := '1'; |
end if; |
else |
if state.y < 0 then |
sign := '1'; |
else |
sign := '0'; |
end if; |
end if; |
|
|
|
if state.do_shift = '1' then |
-- get the angle, do the shifting and set the right angle |
|
if sign = '1' then |
|
-- circular case |
if state.mode( 1 downto 0 ) = VAL_MODE_CIR then |
|
state.a_tmp <= resize( - angular_lut( to_integer( state.i ), state.mode( 1 downto 0 ), A_WIDTH), A_WIDTH_I ); |
state.y_sh <= - SHIFT_RIGHT( state.y, to_integer( state.i ) ); |
|
-- hyperbolic case |
elsif state.mode( 1 downto 0 ) = VAL_MODE_HYP then |
|
state.a_tmp <= resize( - angular_lut( to_integer( state.i ), state.mode( 1 downto 0 ), A_WIDTH), A_WIDTH_I ); |
state.y_sh <= SHIFT_RIGHT( state.y, to_integer( state.i ) ); |
|
-- linear case |
else |
|
state.a_tmp <= resize( - angular_lut( to_integer( state.i ), state.mode( 1 downto 0 ), A_WIDTH ), A_WIDTH_I ) ; |
state.y_sh <= ( others => '0' ); |
|
end if; |
state.x_sh <= SHIFT_RIGHT( state.x, to_integer( state.i ) ); |
|
else |
|
-- circular case |
if state.mode( 1 downto 0 ) = VAL_MODE_CIR then |
|
state.a_tmp <= resize( angular_lut( to_integer( state.i ), state.mode( 1 downto 0 ), A_WIDTH ), A_WIDTH_I ); |
state.y_sh <= SHIFT_RIGHT( state.y, to_integer( state.i ) ); |
|
-- hyperbolic case |
elsif state.mode( 1 downto 0 ) = VAL_MODE_HYP then |
|
state.a_tmp <= resize( angular_lut( to_integer( state.i ), state.mode( 1 downto 0 ), A_WIDTH ), A_WIDTH_I ); |
state.y_sh <= - SHIFT_RIGHT( state.y, to_integer( state.i ) ); |
|
-- linear case |
else |
|
state.a_tmp <= resize( angular_lut( to_integer( state.i ), state.mode( 1 downto 0 ), A_WIDTH ), A_WIDTH_I ) ; |
state.y_sh <= ( others => '0' ); |
|
end if; |
state.x_sh <= - SHIFT_RIGHT( state.x, to_integer( state.i ) ); |
|
end if; |
state.do_shift <= '0'; |
|
-- abort condition |
if( state.mode( I_FLAG_VEC_ROT ) = '0' and |
state.a = 0 ) then |
state.st <= ST_RM_GAIN; |
state.i <= ( others => '0' ); |
elsif( state.mode( I_FLAG_VEC_ROT ) = '0' and |
state.a = state.alst ) then |
state.st <= ST_RM_GAIN; |
state.i <= ( others => '0' ); |
elsif( state.mode( I_FLAG_VEC_ROT ) = '1' and |
state.y = 0 ) then |
state.st <= ST_RM_GAIN; |
state.i <= ( others => '0' ); |
elsif( state.mode( I_FLAG_VEC_ROT ) = '1' and |
( state.y = state.ylst ) ) then |
state.st <= ST_RM_GAIN; |
state.i <= ( others => '0' ); |
end if; |
|
state.ylst <= state.y; |
state.alst <= state.a; |
|
|
else |
state.x <= state.x + state.y_sh; |
state.y <= state.y + state.x_sh; |
state.a <= state.a + state.a_tmp; |
if VAL_MODE_HYP = state.mode( 1 downto 0 ) and |
state.repeate = '0' and |
repeat_hyperbolic_it( to_integer( state.i ) ) then |
state.repeate <= '1'; |
else |
state.repeate <= '0'; |
state.i <= state.i+1; |
end if; |
state.do_shift <= '1'; |
end if; |
|
|
|
|
|
-- |
-- removal of the cordic gain |
-- |
elsif state.st = ST_RM_GAIN then |
-- we need RM_GAIN+1 cycles to |
-- calculate the RM_GAIN steps |
if state.i = (RM_GAIN) then |
state.st <= ST_DONE; |
state.done <= '1'; |
state.i <= ( others => '0' ); |
else |
state.i <= state.i + 1; |
end if; |
|
if state.mode( 1 downto 0 ) = VAL_MODE_CIR then |
mult_0_61( state.x, state.x_sh, state.x_sum, to_integer( state.i ), RM_GAIN ); |
mult_0_61( state.y, state.y_sh, state.y_sum, to_integer( state.i ), RM_GAIN ); |
elsif state.mode( 1 downto 0 ) = VAL_MODE_HYP then |
mult_0_21( state.x, state.x_sh, state.x_sum, to_integer( state.i ), RM_GAIN ); |
mult_0_21( state.y, state.y_sh, state.y_sum, to_integer( state.i ), RM_GAIN ); |
else |
-- TODO merge ST_DONE and state.done |
state.done <= '1'; |
state.st <= ST_DONE; |
state.x_sum <= state.x; |
state.y_sum <= state.y; |
end if; |
|
|
elsif state.st = ST_DONE then |
state.st <= ST_IDLE; |
state.done <= '0'; |
end if; |
-- end states |
|
|
|
end if; |
-- end ena |
|
|
end if; |
-- end clk |
|
end process; |
done <= state.done ; |
x_o <= std_logic_vector( state.x_sum ); |
y_o <= std_logic_vector( state.y_sum ); |
a_o <= std_logic_vector( state.a ); |
|
end architecture BEHAVIORAL; |
|
|
|
/trunk/c_octave/cordic_iterative.c
0,0 → 1,693
/*************************************************************************** |
* * |
* File : cordic_iterative.c * |
* Project : YAC (Yet Another CORDIC Core) * |
* Creation : Feb. 2014 * |
* Limitations : * |
* Platform : Linux, Mac, Windows * |
* Target : Octave, Matlab, Standalone-Application * |
* * |
* Author(s): : Christian Haettich * |
* Email : feddischson@opencores.org * |
* * |
* * |
** ** |
* * |
* Description * |
* C-implementation of an interative cordic. * |
* General information about the CORDIC algorithm can be found * |
* here: - http://en.wikipedia.org/wiki/CORDIC * |
* - http://en.wikibooks.org/wiki/Digital_Circuits/CORDIC * |
* * |
* * |
** ** |
* * |
* TODO * |
* Some documentation and function description * |
* * |
* * |
* * |
* * |
**************************************************************************** |
* * |
* Copyright Notice * |
* * |
* This file is part of YAC - Yet Another CORDIC Core * |
* Copyright (c) 2014, Author(s), All rights reserved. * |
* * |
* YAC is free software; you can redistribute it and/or * |
* modify it under the terms of the GNU Lesser General Public * |
* License as published by the Free Software Foundation; either * |
* version 3.0 of the License, or (at your option) any later version. * |
* * |
* YAC is distributed in the hope that it will be useful, * |
* but WITHOUT ANY WARRANTY; without even the implied warranty of * |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * |
* Lesser General Public License for more details. * |
* * |
* You should have received a copy of the GNU Lesser General Public * |
* License along with this library. If not, download it from * |
* http://www.gnu.org/licenses/lgpl * |
* * |
***************************************************************************/ |
|
|
|
#include <stdio.h> |
#include <stdlib.h> |
#include <math.h> |
#include "mex.h" |
|
/* enable debug output */ |
#define PRINT_DEBUG 0 |
|
|
/* #define CORDIC_ROUNDING 0.5 */ |
#define CORDIC_ROUNDING 0.0 |
|
|
/* the supported modes */ |
#define C_FLAG_VEC_ROT 0x08 |
#define C_FLAG_ATAN_3 0x04 |
#define C_MODE_MSK 0x03 |
#define C_MODE_CIR 0x00 |
#define C_MODE_LIN 0x01 |
#define C_MODE_HYP 0x02 |
|
|
|
#define PRINT mexPrintf |
|
|
|
void cordic_int( long long int x_i, |
long long int y_i, |
long long int a_i, |
long long int * x_o, |
long long int * y_o, |
long long int * a_o, |
int * it_o, |
int mode, |
int XY_WIDTH, |
int A_WIDTH, |
int GUARD_BITS, |
int RM_GAIN ); |
int cordic_int_dbg ( long long int x, |
long long int y, |
long long int a, |
int mode, |
int it, |
char* msg ); |
int cordic_int_init ( long long int *x, |
long long int *y, |
long long int *a, |
int mode, |
int A_WIDTH, |
int XY_WIDTH ); |
void cordic_int_rm_gain( long long int *x, |
long long int *y, |
int mode, |
int rm_gain ); |
int cordic_int_rotate( long long int * x, |
long long int * y, |
long long int * a, |
int mode, |
int A_WIDTH ); |
long long int cordic_int_lut ( int mode, |
int it, |
int A_WIDTH ); |
|
|
|
|
|
|
void mexFunction(int nlhs, mxArray *plhs[], |
int nrhs, const mxArray *prhs[]) |
{ |
double *inx,*iny,*inz,*outx,*outy,*outz,*outi; |
double mode; |
double xy_width; |
double a_width; |
double guard_bits; |
double rm_gain; |
|
int mrowsx,ncolsx,mrowsy,ncolsy,mrowsz,ncolsz; |
int i; |
int it; |
if(nrhs!=8 ) |
mexErrMsgTxt("8 input arguments required"); |
if(nlhs!=4) |
mexErrMsgTxt("4 output arguments required"); |
|
if (!mxIsDouble(prhs[0]) || mxIsComplex(prhs[0])) |
mexErrMsgTxt("Input x must be double and non-complex"); |
|
if (!mxIsDouble(prhs[1]) || mxIsComplex(prhs[1])) |
mexErrMsgTxt("Input y must be double and non-complex"); |
|
if (!mxIsDouble(prhs[2]) || mxIsComplex(prhs[2])) |
mexErrMsgTxt("Input a must be double and non-complex"); |
|
mrowsx = mxGetM(prhs[0]); |
ncolsx = mxGetN(prhs[0]); |
mrowsy = mxGetM(prhs[1]); |
ncolsy = mxGetN(prhs[1]); |
mrowsz = mxGetM(prhs[2]); |
ncolsz = mxGetN(prhs[2]); |
|
|
|
if (mrowsx > 1 || mrowsy >1 || mrowsz > 1) |
mexErrMsgTxt("Input vector must have the size Nx1."); |
|
/* printf("%d %d %d\n", ncolsx, ncolsy, ncolsa); */ |
|
if (ncolsx!=ncolsy || ncolsx!=ncolsz || ncolsy!=ncolsz) |
mexErrMsgTxt("Input vectors don't have the same length!"); |
|
|
plhs[0] = mxCreateDoubleMatrix(mrowsx,ncolsx,mxREAL); |
plhs[1] = mxCreateDoubleMatrix(mrowsy,ncolsy,mxREAL); |
plhs[2] = mxCreateDoubleMatrix(mrowsz,ncolsz,mxREAL); |
plhs[3] = mxCreateDoubleMatrix(mrowsz,ncolsz,mxREAL); |
|
inx = mxGetPr(prhs[0]); |
iny = mxGetPr(prhs[1]); |
inz = mxGetPr(prhs[2]); |
mode = mxGetScalar(prhs[3]); |
xy_width = mxGetScalar(prhs[4]); |
a_width = mxGetScalar(prhs[5]); |
guard_bits = mxGetScalar(prhs[6]); |
rm_gain = mxGetScalar(prhs[7]); |
|
outx= mxGetPr(plhs[0]); |
outy= mxGetPr(plhs[1]); |
outz= mxGetPr(plhs[2]); |
outi= mxGetPr(plhs[3]); |
|
for( i = 0; i < ncolsx; i++ ) |
{ |
long long int inx_i = inx[ i ]; |
long long int iny_i = iny[ i ]; |
long long int inz_i = inz[ i ]; |
long long int outx_i = 0; |
long long int outy_i = 0; |
long long int outz_i = 0; |
/* PRINT("x: %lld, y: %lld, a: %lld\n", inx_i, iny_i, inz_i ); */ |
|
cordic_int( inx_i, iny_i, inz_i, |
&outx_i, &outy_i, &outz_i, |
&it, mode, |
xy_width, a_width, guard_bits, rm_gain ); |
outx[i] = outx_i; |
outy[i] = outy_i; |
outz[i] = outz_i; |
outi[i] = it; |
|
|
} |
} |
|
|
|
|
|
|
void cordic_int( long long int x_i, |
long long int y_i, |
long long int a_i, |
long long int * x_o, |
long long int * y_o, |
long long int * a_o, |
int * it_o, |
int mode, |
int XY_WIDTH, |
int A_WIDTH, |
int GUARD_BITS, |
int RM_GAIN ) |
{ |
long long int x; |
long long int y; |
long long int a; |
long long int s; |
int ov; |
int it = 0; |
|
|
|
|
/* total with, including guard bits */ |
int XY_WIDTH_G = XY_WIDTH + GUARD_BITS; |
|
cordic_int_dbg( x_i, y_i, a_i, mode, 0, "input" ); |
|
if( !cordic_int_init( &x_i, &y_i, &a_i, mode, A_WIDTH, XY_WIDTH ) ) |
{ |
|
it = cordic_int_rotate( &x_i, &y_i, &a_i, mode, A_WIDTH ); |
|
cordic_int_rm_gain( &x_i, &y_i, mode, RM_GAIN ); |
} |
|
*x_o = x_i; |
*y_o = y_i; |
*a_o = a_i; |
*it_o = it; |
|
} |
|
|
|
|
|
|
|
int cordic_int_init( long long int *x, |
long long int *y, |
long long int *a, |
int mode, |
int A_WIDTH, |
int XY_WIDTH ) |
{ |
int already_done = 0; |
|
|
long long int PI = ( long long int )( M_PI * pow( 2, A_WIDTH-1 ) + 0.5 ); |
long long int PI_H = (long long int)( M_PI * pow( 2, A_WIDTH-2 ) + 0.5 ); |
|
long long int XY_MAX = pow( 2, XY_WIDTH-1 )-1; |
|
cordic_int_dbg( *x, *y, *a, mode, 0, "before init" ); |
|
|
/* Circular rotation mode */ |
if( 0 == ( mode & C_FLAG_VEC_ROT ) && |
C_MODE_CIR == ( mode & C_MODE_MSK ) ) |
{ |
/* move from third quadrant to first |
quadrant if necessary */ |
if( *a < - PI_H ) |
{ |
if( ! (mode & C_FLAG_ATAN_3) ) |
*a += PI; |
*x = -*x; |
*y = -*y; |
#if PRINT_DEBUG > 0 |
PRINT("move from third quadrand"); |
#endif |
} |
/* move from second quadrant to fourth |
quadrant if necessary */ |
else if( *a > PI_H ) |
{ |
if( ! (mode & C_FLAG_ATAN_3) ) |
*a -= PI; |
*x = -*x; |
*y = -*y; |
#if PRINT_DEBUG > 0 |
PRINT("move from second quadrand\n" ); |
#endif |
} |
} |
|
/* circular vector mode */ |
else if ( 0 != ( mode & C_FLAG_VEC_ROT ) && |
C_MODE_CIR == ( mode & C_MODE_MSK ) ) |
{ |
|
if( *x == 0 && *y == 0 ) |
{ |
already_done = 1; |
*a = 0; |
#if PRINT_DEBUG > 0 |
PRINT( "Zero input, skipping rotations \n" ); |
#endif |
} |
else if( *x == XY_MAX && *y == XY_MAX ) |
{ |
#if PRINT_DEBUG > 0 |
PRINT( "All max, skipping rotations 1\n" ); |
#endif |
*a = cordic_int_lut( mode, 0, A_WIDTH ); |
*x = sqrt( 2 ) * pow( 2, XY_WIDTH-1 ); |
already_done = 1; |
} |
else if( *x == -XY_MAX && *y == -XY_MAX ) |
{ |
#if PRINT_DEBUG > 0 |
PRINT( "All max, skipping rotations 2\n" ); |
#endif |
*a = cordic_int_lut( mode, 0, A_WIDTH ) - PI; |
*x = sqrt( 2 ) * pow( 2, XY_WIDTH-1 ); |
already_done = 1; |
} |
else if( *x == XY_MAX && *y == -XY_MAX ) |
{ |
#if PRINT_DEBUG > 0 |
PRINT( "All max, skipping rotations 3\n" ); |
#endif |
*a = -cordic_int_lut( mode, 0, A_WIDTH ); |
*x = sqrt( 2 ) * pow( 2, XY_WIDTH-1 ); |
already_done = 1; |
} |
else if( *x == -XY_MAX && *y == XY_MAX ) |
{ |
#if PRINT_DEBUG > 0 |
PRINT( "All max, skipping rotations 4\n" ); |
#endif |
*a = PI - cordic_int_lut( mode, 0, A_WIDTH ); |
*x = sqrt( 2 ) * pow( 2, XY_WIDTH-1 ); |
already_done = 1; |
} |
|
|
|
else if( *x == 0 && *y > 0 ) |
{ |
*a = PI_H; |
*x = *y; |
already_done = 1; |
#if PRINT_DEBUG > 0 |
PRINT( "Fixed value of pi/2, skipping rotations" ); |
#endif |
*y = 0; |
} |
else if( *x == 0 && *y < 0 ) |
{ |
*a = -PI_H; |
*x = -*y; |
*y = 0; |
already_done = 1; |
#if PRINT_DEBUG > 0 |
PRINT( "Fixed value of -pi/2, skipping rotations" ); |
#endif |
} |
else if( *x < 0 && *y >= 0 ) |
{ |
*x = -*x; |
*y = -*y; |
*a = PI; |
#if PRINT_DEBUG > 0 |
PRINT("pre-rotation from second to the fourth quadrant\n" ); |
#endif |
} |
else if( *x < 0 && *y < 0 ) |
{ |
*x = -*x; |
*y = -*y; |
*a = -PI; |
#if PRINT_DEBUG > 0 |
PRINT("pre-rotation from third to first quadrand\n" ); |
#endif |
} |
else |
*a = 0; |
} |
/* linear vector mode */ |
else if ( 0 != ( mode & C_FLAG_VEC_ROT ) && |
C_MODE_LIN == ( mode & C_MODE_MSK ) ) |
{ |
if( *x < 0 ) |
{ |
*x = -*x; |
*y = -*y; |
} |
*a = 0; |
} |
|
cordic_int_dbg( *x, *y, *a, mode, 0, "after init" ); |
return already_done; |
} |
|
|
|
int cordic_int_dbg( long long int x, |
long long int y, |
long long int a, |
int mode, |
int it, |
char* msg ) |
{ |
#if PRINT_DEBUG > 0 |
PRINT( "%20s: mode = %d, iteration %d, x = % 10.lld, y = %10.lld, a = %10.lld \n", |
msg,mode,it,x,y,a ); |
#endif |
} |
|
int cordic_int_repeat( iteration, mode ) |
{ |
int i = 4; |
|
if( C_MODE_HYP != ( mode & C_MODE_MSK ) ) |
return 0; |
|
|
while( 1 ) |
{ |
if( i == iteration ) |
return 1; |
else if( i > iteration ) |
return 0; |
i = i * 3 + 1; |
} |
} |
|
|
|
|
int cordic_int_rotate( long long int * x, |
long long int * y, |
long long int * a, |
int mode, |
int A_WIDTH ) |
{ |
int it = 0; |
long long int xsh, ysh; |
long long int ylst, alst; |
int sign; |
int repeat = 0; |
|
while( 1 ) |
{ |
/* get the sign */ |
if( 0 == ( mode & C_FLAG_VEC_ROT ) ) |
sign = ( *a >= 0 ); |
else |
sign = !( *y >= 0 ); |
|
/* shift operation: hyperbolic case*/ |
if( C_MODE_HYP == ( mode & C_MODE_MSK ) ) |
{ |
xsh = *x >> (it+1); |
ysh = *y >> (it+1); |
} |
/* shift operation: circular and linear case*/ |
else |
{ |
xsh = *x >> it; |
ysh = *y >> it; |
} |
|
if( sign == 1 ) |
{ |
*a -= cordic_int_lut( mode, it, A_WIDTH ); |
|
if( C_MODE_CIR == ( mode & C_MODE_MSK ) ) |
{ |
*x = *x - ysh; |
*y = *y + xsh; |
} |
else |
if( C_MODE_LIN == ( mode & C_MODE_MSK ) ) |
{ |
*x = *x; |
*y = *y + xsh; |
} |
else |
{ |
*x = *x + ysh; |
*y = *y + xsh; |
} |
} |
else |
{ |
*a += cordic_int_lut( mode, it, A_WIDTH ); |
if( C_MODE_CIR == ( mode & C_MODE_MSK ) ) |
{ |
*x = *x + ysh; |
*y = *y - xsh; |
} |
else |
if( C_MODE_LIN == ( mode & C_MODE_MSK ) ) |
{ |
*x = *x; |
*y = *y - xsh; |
} |
else |
{ |
*x = *x - ysh; |
*y = *y - xsh; |
} |
} |
cordic_int_dbg( *x, *y, *a, mode, it, "after rotation" ); |
|
/* abort condition */ |
if( ( mode & C_FLAG_VEC_ROT ) == 0 && |
( *a == 0 /* || *a == -1 */ ) ) |
break; |
if( ( mode & C_FLAG_VEC_ROT ) == 0 && |
( *a == alst ) ) |
break; |
|
if( ( mode & C_FLAG_VEC_ROT ) != 0 && |
( *y == 0 /*|| *y == -1 */ ) ) |
break; |
if( ( mode & C_FLAG_VEC_ROT ) != 0 && |
( *y == ylst ) ) |
break; |
|
else if( it > 40 ) |
{ |
PRINT( "ERROR: abort %lld %lld %lld %lld - %d - %d!\n", *a, alst, *y, ylst, mode, *y == ylst ); |
it = -1; |
break; |
} |
|
|
ylst = *y; |
alst = *a; |
if( repeat == 0 && cordic_int_repeat( it, mode ) ) |
{ |
repeat = 1; |
#if PRINT_DEBUG |
mexPrintf( "repeat it %d\n" , it ); |
#endif |
} |
else |
{ |
repeat = 0; |
it++; |
} |
} |
return it; |
} |
|
|
|
#define SCALE_VAL( _W_ )( (double)( (long long int) 1 << (long long int)( _W_ -1 ) ) ) |
|
long long int cordic_int_lut( int mode, int it, int A_WIDTH ) |
{ |
long long int lut_val; |
if( C_MODE_CIR == ( mode & C_MODE_MSK ) ) |
{ |
if( it <= 10 ) |
lut_val = (long long int)( atan( pow( 2, -it ) ) * pow( 2, A_WIDTH-1 ) ); |
else |
lut_val = pow( 2, A_WIDTH-1-it ); /* (long long int)( SCALE_VAL( A_WIDTH-it ) ); */ |
} |
else |
if( C_MODE_LIN == ( mode & C_MODE_MSK ) ) |
{ |
lut_val = (long long int)( 1.0 / (double)( ( long long int )1 << (long long int)it ) |
* SCALE_VAL( A_WIDTH ) -1 ); |
} |
else |
{ |
lut_val = (long long int)( atanh( 1.0 / (double)( (long long int)1 << ( long long int )(it+1) ) ) |
* SCALE_VAL( A_WIDTH ) ); |
} |
return lut_val; |
} |
|
|
|
|
/** |
* |
* Cordic gain: |
* |
* |
* |
*/ |
void cordic_int_rm_gain( long long int *x, |
long long int *y, |
int mode, |
int rm_gain ) |
{ |
/* for the non-linear case: remove cordic gain if RM_GAIN > 0 */ |
if( C_MODE_CIR == ( mode & C_MODE_MSK ) ) |
{ |
|
|
switch( rm_gain ) |
{ |
case 1: *x = + ( *x >> 1 ) ; break; /* error: 0.1072529350 */ |
case 2: *x = + ( *x >> 1 ) - ( *x >> 4 ) ; break; /* error: 0.1697529350 */ |
case 3: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 5 ) ; break; /* error: 0.0135029350 */ |
case 4: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 8 ) ; break; /* error: 0.0017841850 */ |
case 5: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 9 ) - ( *x >> 12 ) ; break; /* error: 0.0000752006 */ |
case 6: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 9 ) - ( *x >> 13 ) - ( *x >> 14 ) ; break; /* error: 0.0000141655 */ |
case 7: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 9 ) - ( *x >> 13 ) - ( *x >> 14 ) - ( *x >> 17 ) ; break; /* error: 0.0000217949 */ |
case 8: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 9 ) - ( *x >> 13 ) - ( *x >> 14 ) + ( *x >> 16 ) - ( *x >> 19 ) ; break; /* error: 0.0000008140 */ |
case 9: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 9 ) - ( *x >> 13 ) - ( *x >> 14 ) + ( *x >> 16 ) - ( *x >> 20 ) - ( *x >> 22 ) ; break; /* error: 0.0000000988 */ |
case 10: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 9 ) - ( *x >> 13 ) - ( *x >> 14 ) + ( *x >> 16 ) - ( *x >> 20 ) - ( *x >> 23 ) - ( *x >> 25 ) ; break; /* error: 0.0000000094 */ |
case 11: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 9 ) - ( *x >> 13 ) - ( *x >> 14 ) + ( *x >> 16 ) - ( *x >> 20 ) - ( *x >> 23 ) - ( *x >> 26 ) - ( *x >> 27 ) ; break; /* error: 0.0000000019 */ |
case 12: *x = + ( *x >> 1 ) + ( *x >> 3 ) - ( *x >> 6 ) - ( *x >> 9 ) - ( *x >> 13 ) - ( *x >> 14 ) + ( *x >> 16 ) - ( *x >> 20 ) - ( *x >> 23 ) - ( *x >> 26 ) - ( *x >> 28 ) - ( *x >> 29 ) ; break; /* error: 0.0000000001 */ |
default: *x = *x; break; |
} |
switch( rm_gain ) |
{ |
case 1: *y = + ( *y >> 1 ) ; break; /* error: 0.1072529350 */ |
case 2: *y = + ( *y >> 1 ) - ( *y >> 4 ) ; break; /* error: 0.1697529350 */ |
case 3: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 5 ) ; break; /* error: 0.0135029350 */ |
case 4: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 8 ) ; break; /* error: 0.0017841850 */ |
case 5: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 9 ) - ( *y >> 12 ) ; break; /* error: 0.0000752006 */ |
case 6: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 9 ) - ( *y >> 13 ) - ( *y >> 14 ) ; break; /* error: 0.0000141655 */ |
case 7: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 9 ) - ( *y >> 13 ) - ( *y >> 14 ) - ( *y >> 17 ) ; break; /* error: 0.0000217949 */ |
case 8: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 9 ) - ( *y >> 13 ) - ( *y >> 14 ) + ( *y >> 16 ) - ( *y >> 19 ) ; break; /* error: 0.0000008140 */ |
case 9: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 9 ) - ( *y >> 13 ) - ( *y >> 14 ) + ( *y >> 16 ) - ( *y >> 20 ) - ( *y >> 22 ) ; break; /* error: 0.0000000988 */ |
case 10: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 9 ) - ( *y >> 13 ) - ( *y >> 14 ) + ( *y >> 16 ) - ( *y >> 20 ) - ( *y >> 23 ) - ( *y >> 25 ) ; break; /* error: 0.0000000094 */ |
case 11: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 9 ) - ( *y >> 13 ) - ( *y >> 14 ) + ( *y >> 16 ) - ( *y >> 20 ) - ( *y >> 23 ) - ( *y >> 26 ) - ( *y >> 27 ) ; break; /* error: 0.0000000019 */ |
case 12: *y = + ( *y >> 1 ) + ( *y >> 3 ) - ( *y >> 6 ) - ( *y >> 9 ) - ( *y >> 13 ) - ( *y >> 14 ) + ( *y >> 16 ) - ( *y >> 20 ) - ( *y >> 23 ) - ( *y >> 26 ) - ( *y >> 28 ) - ( *y >> 29 ) ; break; /* error: 0.0000000001 */ |
default: *x = *y; break; |
} |
|
} |
else |
if( C_MODE_HYP == ( mode & C_MODE_MSK ) ) |
{ |
switch( rm_gain ) |
{ |
case 1: *x = *x - ( *x >> 3 ) ; break; /* error: 0.3324970678 */ |
case 2: *x = *x + ( *x >> 2 ) - ( *x >> 4 ) ; break; /* error: 0.0199970678 */ |
case 3: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 6 ) ; break; /* error: 0.0043720678 */ |
case 4: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) ; break; /* error: 0.0004658178 */ |
case 5: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) - ( *x >> 12 ) ; break; /* error: 0.0007099584 */ |
case 6: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) + ( *x >> 11 ) - ( *x >> 15 ) ; break; /* error: 0.0000080541 */ |
case 7: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) + ( *x >> 11 ) - ( *x >> 16 ) - ( *x >> 17 ) ; break; /* error: 0.0000004247 */ |
case 8: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) + ( *x >> 11 ) - ( *x >> 16 ) - ( *x >> 17 ) - ( *x >> 22 ) ; break; /* error: 0.0000006631 */ |
case 9: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) + ( *x >> 11 ) - ( *x >> 16 ) - ( *x >> 17 ) + ( *x >> 21 ) - ( *x >> 24 ) ; break; /* error: 0.0000000075 */ |
case 10: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) + ( *x >> 11 ) - ( *x >> 16 ) - ( *x >> 17 ) + ( *x >> 21 ) - ( *x >> 24 ) + ( *x >> 27 ) ; break; /* error: 0.0000000000 */ |
case 11: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) + ( *x >> 11 ) - ( *x >> 16 ) - ( *x >> 17 ) + ( *x >> 21 ) - ( *x >> 24 ) + ( *x >> 27 ) - ( *x >> 37 ) ; break; /* error: 0.0000000000 */ |
case 12: *x = *x + ( *x >> 2 ) - ( *x >> 5 ) - ( *x >> 7 ) - ( *x >> 8 ) + ( *x >> 11 ) - ( *x >> 16 ) - ( *x >> 17 ) + ( *x >> 21 ) - ( *x >> 24 ) + ( *x >> 27 ) + ( *x >> 36 ) - ( *x >> 39 ) ; break; /* error: 0.0000000000 */ |
} |
switch( rm_gain ) |
{ |
case 1: *y = *y - ( *y >> 3 ) ; break; /* error: 0.3324970678 */ |
case 2: *y = *y + ( *y >> 2 ) - ( *y >> 4 ) ; break; /* error: 0.0199970678 */ |
case 3: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 6 ) ; break; /* error: 0.0043720678 */ |
case 4: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) ; break; /* error: 0.0004658178 */ |
case 5: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) - ( *y >> 12 ) ; break; /* error: 0.0007099584 */ |
case 6: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) + ( *y >> 11 ) - ( *y >> 15 ) ; break; /* error: 0.0000080541 */ |
case 7: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) + ( *y >> 11 ) - ( *y >> 16 ) - ( *y >> 17 ) ; break; /* error: 0.0000004247 */ |
case 8: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) + ( *y >> 11 ) - ( *y >> 16 ) - ( *y >> 17 ) - ( *y >> 22 ) ; break; /* error: 0.0000006631 */ |
case 9: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) + ( *y >> 11 ) - ( *y >> 16 ) - ( *y >> 17 ) + ( *y >> 21 ) - ( *y >> 24 ) ; break; /* error: 0.0000000075 */ |
case 10: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) + ( *y >> 11 ) - ( *y >> 16 ) - ( *y >> 17 ) + ( *y >> 21 ) - ( *y >> 24 ) + ( *y >> 27 ) ; break; /* error: 0.0000000000 */ |
case 11: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) + ( *y >> 11 ) - ( *y >> 16 ) - ( *y >> 17 ) + ( *y >> 21 ) - ( *y >> 24 ) + ( *y >> 27 ) - ( *y >> 37 ) ; break; /* error: 0.0000000000 */ |
case 12: *y = *y + ( *y >> 2 ) - ( *y >> 5 ) - ( *y >> 7 ) - ( *y >> 8 ) + ( *y >> 11 ) - ( *y >> 16 ) - ( *y >> 17 ) + ( *y >> 21 ) - ( *y >> 24 ) + ( *y >> 27 ) + ( *y >> 36 ) - ( *y >> 39 ) ; break; /* error: 0.0000000000 */ |
} |
} |
} |
|
/trunk/c_octave/cordic_iterative_code.m
0,0 → 1,330
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
%%%% %%%% |
%%%% File : cordic_iterative_code.m %%%% |
%%%% Project : YAC (Yet Another CORDIC Core) %%%% |
%%%% Creation : Feb. 2014 %%%% |
%%%% Limitations : %%%% |
%%%% Platform : Linux, Mac, Windows %%%% |
%%%% Target : Octave, Matlab %%%% |
%%%% %%%% |
%%%% Author(s): : Christian Haettich %%%% |
%%%% Email : feddischson@opencores.org %%%% |
%%%% %%%% |
%%%% %%%% |
%%%%% %%%%% |
%%%% %%%% |
%%%% Description %%%% |
%%%% Script to create VHDL and C code. %%%% |
%%%% Two functionalities are created: %%%% |
%%%% %%%% |
%%%% - A division by a fixed value %%%% |
%%%% (to remove the cordic gain) %%%% |
%%%% %%%% |
%%%% - Atan/Atanh/Linear lookup table %%%% |
%%%%% %%%%% |
%%%% %%%% |
%%%% TODO %%%% |
%%%% Some documentation and function description %%%% |
%%%% %%%% |
%%%% %%%% |
%%%% %%%% |
%%%% %%%% |
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
%%%% %%%% |
%%%% Copyright Notice %%%% |
%%%% %%%% |
%%%% This file is part of YAC - Yet Another CORDIC Core %%%% |
%%%% Copyright (c) 2014, Author(s), All rights reserved. %%%% |
%%%% %%%% |
%%%% YAC is free software; you can redistribute it and/or %%%% |
%%%% modify it under the terms of the GNU Lesser General Public %%%% |
%%%% License as published by the Free Software Foundation; either %%%% |
%%%% version 3.0 of the License, or (at your option) any later version. %%%% |
%%%% %%%% |
%%%% YAC is distributed in the hope that it will be useful, %%%% |
%%%% but WITHOUT ANY WARRANTY; without even the implied warranty of %%%% |
%%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU %%%% |
%%%% Lesser General Public License for more details. %%%% |
%%%% %%%% |
%%%% You should have received a copy of the GNU Lesser General Public %%%% |
%%%% License along with this library. If not, download it from %%%% |
%%%% http://www.gnu.org/licenses/lgpl %%%% |
%%%% %%%% |
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
|
|
|
|
function cordic_iterative_code( outfile ) |
|
if ~exist( 'outfile', 'var' ) |
outfile = 'autogen_code.txt'; |
end |
|
fid = fopen( outfile, 'w' ); |
|
% TODO: calculate these values |
K0 = 0.607252935009; |
K1 = 0.207497067763; |
%prod( sqrt( 1-2.^(-2 .* [ 1 : 100000 ] ) ) ) |
|
|
signs = get_rm_gain_shifts( K0, 30 ); |
print_rm_gain_code( fid, signs, K0, 1, 1, 0 ); |
|
signs = get_rm_gain_shifts( K1, 30 ); |
print_rm_gain_code( fid, signs, K1, 1, 1, 1 ); |
|
signs = get_rm_gain_shifts( K0, 30 ); |
print_rm_gain_code( fid, signs, K0, 1, 0, 0 ); |
|
signs = get_rm_gain_shifts( K1, 30 ); |
print_rm_gain_code( fid, signs, K1, 1, 0, 1 ); |
|
MAX_A_WIDTH = 32; |
print_angular_lut( fid, MAX_A_WIDTH ); |
|
|
fclose( fid ); |
|
end |
|
|
|
|
function print_angular_lut( fid, MAX_A_WIDTH ) |
|
|
values = round( atan( 2.^-[0:MAX_A_WIDTH] ) / pi * 2^(MAX_A_WIDTH-1) ); |
|
|
fprintf( fid, '-- Auto-generated function \n' ); |
fprintf( fid, '-- by matlab (see c_octave/cordic_iterative_code.m)\n' ); |
fprintf( fid, 'function angular_lut( n : integer; mode : std_logic_vector; ANG_WIDTH : natural ) return signed is\n' ); |
fprintf( fid, ' variable result : signed( ANG_WIDTH-1 downto 0 );\n' ); |
fprintf( fid, ' variable temp : signed( MAX_A_WIDTH-1 downto 0 );\n' ); |
fprintf( fid, ' begin\n' ); |
fprintf( fid, ' if mode = VAL_MODE_CIR then\n' ); |
fprintf( fid, ' case n is\n' ); |
for x = 0 : 10 |
val = floor( atan( 2^-x ) * 2^(MAX_A_WIDTH+2-1) ); |
fprintf( fid, ' when %d => temp := "', x ); |
fprintf( fid, '%c', dec2bin( val, MAX_A_WIDTH+2 ) ); |
fprintf( fid, '"; \t-- %d\n', val ); |
end |
fprintf( fid, ' when others => temp := to_signed( 2**(MAX_A_WIDTH-1-n), MAX_A_WIDTH );\n' ); |
fprintf( fid, ' end case;\n' ); |
fprintf( fid, ' elsif mode = VAL_MODE_HYP then\n' ); |
fprintf( fid, ' case n is\n' ); |
for x = 1 : 10 |
val = floor( atanh( 2^-x ) * 2^(MAX_A_WIDTH+2-1) ); |
fprintf( fid, ' when %d => temp := "', x ); |
fprintf( fid, '%c', dec2bin( val, MAX_A_WIDTH+2 ) ); |
fprintf( fid, '"; \t-- %d\n', val); |
end |
fprintf( fid, ' when others => temp := to_signed( 2**(MAX_A_WIDTH-1-n), MAX_A_WIDTH );\n' ); |
fprintf( fid, ' end case;\n' ); |
fprintf( fid, ' elsif mode = VAL_MODE_LIN then\n' ); |
fprintf( fid, ' temp := ( others => ''0'' );\n' ); |
fprintf( fid, ' temp( temp''high-1-n downto 0 ) := ( others => ''1'' );\n' ); |
fprintf( fid, ' end if;\n' ); |
fprintf( fid, ' result := temp( temp''high downto temp''high-result''length+1 );\n' ); |
fprintf( fid, ' return result;\n' ); |
fprintf( fid, 'end function angular_lut;\n' ); |
end |
|
|
function print_rm_gain_code( fid, signs, value, force_pos_err, c_or_vhdl, plus_one ) |
|
|
% Default values for arguments |
if ~exist( 'force_pos_err', 'var' ) |
force_neg_err = 0; |
end |
|
if ~exist( 'c_or_vhdl', 'var' ) |
c_or_vhdl = 0; |
end |
|
val_str = sprintf( '%4.2f', value ); |
val_str( val_str == '.' ) = ('_' ); |
|
if c_or_vhdl |
fprintf( fid, '/* Auto-generated procedure to multiply "x" with %f */\n', value ); |
fprintf( fid, '/* "shifts" defines the number of shifts, which are used */\n' ); |
fprintf( fid, 'switch( shifts )\n{\n' ); |
end |
i_shift = 1; |
for x = 1 : length( signs ) |
if signs( x ) ~= 0 |
|
tmp = signs( 1 : x ); |
|
|
err = value - sum( tmp .* 2.^-( 1 : length( tmp ) ) ); |
if force_pos_err |
if err < 0 |
|
if( tmp( end ) == 1 ) |
tmp( end+1 ) = -1; |
tmp( end-1 ) = 0; |
else |
tmp( end-1 ) = -1; |
tmp( end ) = 0; |
end |
end |
err = value - sum( tmp .* 2.^-( 1 : length( tmp ) ) ); |
end |
|
index = 1 : length( tmp ); |
index( tmp == 0 ) = []; |
tmp( tmp == 0 ) = []; |
tmp2 = cell( size ( tmp ) ); |
tmp2( tmp == 1 ) = { '+' }; |
tmp2( tmp == -1 ) = { '-' }; |
|
if c_or_vhdl |
|
% C-Code |
if plus_one |
fprintf( fid, ' case %d: x = x ', i_shift ); |
else |
fprintf( fid, ' case %d: x = ', i_shift ); |
end |
|
for y = 1 : length( tmp2 ) |
fprintf( fid, '%c ( x >> %d ) ', tmp2{ y }, index( y ) ); |
end |
fprintf( fid, '; break; /* error: %.10f */ \n', err ); |
else |
|
% VHDL CODE |
|
fprintf( fid, '\n\n--\n' ); |
fprintf( fid, '-- Auto-generated procedure to multiply "a" with %f iteratively\n', value ); |
fprintf( fid, '-- a_sh is a temporary register to store the shifted value, and \n' ); |
fprintf( fid, '-- sum is a temporary register to sum up the result\n' ); |
fprintf( fid, '--\n' ); |
fprintf( fid, 'procedure mult_%s_%.2d( signal a : in signed; \n', val_str, i_shift ); |
fprintf( fid, ' signal a_sh : inout signed; \n' ); |
fprintf( fid, ' signal sum : inout signed; \n' ); |
fprintf( fid, ' cnt : in natural ) is \n' ); |
fprintf( fid, ' begin\n' ); |
fprintf( fid, ' case cnt is\n' ); |
|
if plus_one |
fprintf( fid, ' when 0 => sum <= a;\n' ); |
else |
fprintf( fid, ' when 0 => sum <= to_signed( 0, sum''length );\n' ); |
end |
fprintf( fid, ' a_sh <= SHIFT_RIGHT( a, %d ); \n', index( 1 ) ); |
fprintf( fid, ' when 1 => sum <= sum %c a_sh; \n', tmp2{ 1 } ); |
|
for y = 2 : length( tmp2 ) |
fprintf( fid, ' a_sh <= SHIFT_RIGHT( a, %d );\n', index( y ) ); |
fprintf( fid, ' when %3.d => sum <= sum %c a_sh; \n', y, tmp2{ y } ); |
end |
fprintf( fid, ' when others => sum <= sum;\n' ); |
fprintf( fid, ' end case;\n' ); |
fprintf( fid, 'end procedure mult_%s_%.2d;\n', val_str, i_shift ); |
end |
i_shift = i_shift+1; |
end |
|
end |
if c_or_vhdl |
fprintf( fid, ' default: x = x; break;\n}\n' ); |
end |
|
|
if ~c_or_vhdl |
fprintf( fid, '\n\n--\n' ); |
fprintf( fid, '-- Auto-generated procedure to multiply "a" with %f iteratively\n', value ); |
fprintf( fid, '-- a_sh is a temporary register to store the shifted value, and \n' ); |
fprintf( fid, '-- sum is a temporary register to sum up the result\n' ); |
fprintf( fid, '--\n' ); |
fprintf( fid, 'procedure mult_%s( signal a : in signed; \n', val_str ); |
fprintf( fid, ' signal a_sh : inout signed; \n' ); |
fprintf( fid, ' signal sum : inout signed; \n' ); |
fprintf( fid, ' cnt : in natural; \n' ); |
fprintf( fid, ' constant RM_GAIN : in natural ) is \n' ); |
fprintf( fid, ' begin\n' ); |
fprintf( fid, ' case RM_GAIN is\n' ); |
for y = 1 : length( tmp2 ) |
fprintf( fid, ' when %d => mult_%s_%.2d( a, a_sh, sum, cnt );\n', y, val_str, y ); |
end |
fprintf( fid, ' when others => mult_%s_%.2d( a, a_sh, sum, cnt );\n', val_str, y ); |
fprintf( fid, ' end case;\n' ); |
fprintf( fid, 'end procedure mult_%s;\n', val_str ); |
end |
|
|
end |
|
function signs = get_rm_gain_shifts( value, N_shifts ) |
%N_steps = 50; |
%signs = zeros( 1, N_steps ); |
signs = [ ]; |
from_p_n = 1; % comming from pos or neg |
|
prev_pos_err = inf; |
prev_neg_err = inf; |
i_shift = 0; |
x = 0; |
|
while i_shift < N_shifts |
x = x + 1; |
if isempty( signs ) |
tmp = 0; |
else |
tmp = sum( signs .* 2.^-( 1 : length( signs ) ) ); |
end; |
|
pos_err = value - ( tmp + 2^-x ); |
neg_err = value - ( tmp - 2^-x ); |
signs( end+1 ) = 0; |
if from_p_n == 1 && pos_err < 0 ... |
|| from_p_n == 0 && neg_err > 0 |
prev_pos_err = pos_err; |
prev_neg_err = neg_err; |
continue |
end |
i_shift = i_shift+1; |
|
if from_p_n == 1 && abs( prev_pos_err ) < abs( pos_err ) |
signs( x-1 ) = 1; |
from_p_n = 0; |
neg_err2 = value - ( tmp - 2^-x ); |
if neg_err2 < 0 |
signs( x ) = -1; |
end |
|
elseif from_p_n == 0 && abs( prev_neg_err ) < abs( neg_err ) |
signs( x-1 ) = -1; |
from_p_n = 1; |
pos_err2 = value - ( tmp + 2^-x ); |
if pos_err2 > 0 |
signs( x ) = 1; |
end |
|
|
elseif from_p_n == 1 && abs( prev_pos_err ) >= abs( pos_err ) |
signs( x ) = 1; |
|
elseif from_p_n == 0 && abs( prev_pos_err ) >= abs( pos_err ) |
signs( x ) = -1; |
|
end |
prev_pos_err = pos_err; |
prev_neg_err = neg_err; |
|
end |
|
end |
|
|
|
|
|
/trunk/c_octave/cordic_iterative_test.m
0,0 → 1,608
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
%%%% %%%% |
%%%% File : cordic_iterative_test.m %%%% |
%%%% Project : YAC (Yet Another CORDIC Core) %%%% |
%%%% Creation : Feb. 2014 %%%% |
%%%% Limitations : %%%% |
%%%% Platform : Linux, Mac, Windows %%%% |
%%%% Target : Octave, Matlab %%%% |
%%%% %%%% |
%%%% Author(s): : Christian Haettich %%%% |
%%%% Email : feddischson@opencores.org %%%% |
%%%% %%%% |
%%%% %%%% |
%%%%% %%%%% |
%%%% %%%% |
%%%% Description %%%% |
%%%% Script to test/analyze the cordic C implementation %%%% |
%%%% and to generate stimulus data for RTL simulation. %%%% |
%%%% This created data is used to ensure, that the C %%%% |
%%%% implementation behaves the same than the VHDL %%%% |
%%%% implementation. %%%% |
%%%% %%%% |
%%%% Three tests are implemented: %%%% |
%%%% - Random test values %%%% |
%%%% - Linear increasing values %%%% |
%%%% - Limit values %%%% |
%%%% %%%% |
%%%% %%%% |
%%%% Please do 'mex cordic_iterative.c' to create %%%% |
%%%% the cordic_iterative.mex. %%%% |
%%%% %%%% |
%%%%% %%%%% |
%%%% %%%% |
%%%% TODO %%%% |
%%%% The linear test is not complete %%%% |
%%%% %%%% |
%%%% %%%% |
%%%% %%%% |
%%%% %%%% |
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
%%%% %%%% |
%%%% Copyright Notice %%%% |
%%%% %%%% |
%%%% This file is part of YAC - Yet Another CORDIC Core %%%% |
%%%% Copyright (c) 2014, Author(s), All rights reserved. %%%% |
%%%% %%%% |
%%%% YAC is free software; you can redistribute it and/or %%%% |
%%%% modify it under the terms of the GNU Lesser General Public %%%% |
%%%% License as published by the Free Software Foundation; either %%%% |
%%%% version 3.0 of the License, or (at your option) any later version. %%%% |
%%%% %%%% |
%%%% YAC is distributed in the hope that it will be useful, %%%% |
%%%% but WITHOUT ANY WARRANTY; without even the implied warranty of %%%% |
%%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU %%%% |
%%%% Lesser General Public License for more details. %%%% |
%%%% %%%% |
%%%% You should have received a copy of the GNU Lesser General Public %%%% |
%%%% License along with this library. If not, download it from %%%% |
%%%% http://www.gnu.org/licenses/lgpl %%%% |
%%%% %%%% |
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
function cordic_iterative_test( ) |
|
|
|
% global flags/values, they are static |
% through the whole script and defined below |
global C_FLAG_VEC_ROT C_FLAG_ATAN_3 C_MODE_CIRC C_MODE_LIN C_MODE_HYP |
global XY_WIDTH ANGLEWIDTH GUARDBITS RM_GAIN |
|
|
% |
% flags: they are also define in cordic_iterative.c and |
% cordic_iterative_pkg.vhd |
C_FLAG_VEC_ROT = 2^3; |
C_FLAG_ATAN_3 = 2^2; |
C_MODE_CIRC = 0; |
C_MODE_LIN = 1; |
C_MODE_HYP = 2; |
|
% initialize the random-generator's seed |
rand('seed', 1633); |
|
|
% cordic setup: |
% this must fit to the testbench |
XY_WIDTH = 25; |
ANGLEWIDTH = 25; |
GUARDBITS = 2; |
RM_GAIN = 5; |
|
|
% Number of tests, which are run |
N_TESTS = 10000; |
|
% open test file |
tb_fid = fopen( './tb_data.txt', 'w' ); |
%tb_fid = 0; |
|
|
|
|
|
% |
% run test, which uses random values |
run_random_test( N_TESTS, tb_fid ); |
% |
% run tests, which test limits |
run_limit_test( tb_fid ); |
% |
% run linear value test |
run_linear_test( 1000, tb_fid ); |
|
% close file |
if tb_fid > 0 |
fclose( tb_fid ); |
end |
|
end |
|
|
|
|
function run_limit_test( tb_fid ) |
%RUN_LIMIT_TEST Test the range limit |
% |
% run_limit_test( fid ) |
% |
% This function is used to generate a test pattern |
% with values, which are at the range limit. |
% This values are then processed by the fixed-point YAC |
% implementation. All input and outputs are logged into |
% a testbench pattern file. |
% |
% The argument fid is the file-descriptor of the testbench pattern |
% file. |
% |
|
|
data_a = [ 0 1 0 1 -1 0 -1 1 -1 ]; |
data_b = [ 0 0 1 1 0 -1 -1 -1 1 ]; |
|
data_c = [ 0 0 0 0 0 0 0 0 0 ... |
1 1 1 1 1 1 1 1 1 ... |
-1 -1 -1 -1 -1 -1 -1 -1 -1 ]; |
|
data_d = data_a * pi; |
|
data_a_div = [ 0.5 ,1 -0.5, -1, -0.5, -1 ]; |
data_b_div = [ 1 ,1, 1, 1, -1, -1 ]; |
|
[ ~, ~, atan_err, abs_err, it_1 ] = ccart2pol( data_a, data_b, tb_fid ); |
[ ~, ~, sin_err, cos_err, it_2 ] = cpol2cart( data_d, data_b, tb_fid ); |
[ ~, ~, x_err, y_err, it_3 ] = crot( [ data_a, data_a, data_a], ... |
[ data_b, data_b, data_b], ... |
data_c, tb_fid ); |
[ ~, div_err, it_4 ] = cdiv( data_a_div, data_b_div, tb_fid ); |
[ ~, mul_err, it_5 ] = cmul( data_a, data_b, tb_fid ); |
|
print_result_info( ... |
atan_err, it_1, ... |
abs_err, it_1, ... |
sin_err, it_2, ... |
cos_err, it_2, ... |
x_err, it_3, ... |
y_err, it_3, ... |
div_err, it_4, ... |
mul_err, it_5, ... |
0, 0, ... |
0, 0, ... |
0, 0, ... |
0, 0, ... |
'Limit Value Test' ); |
|
end |
|
|
|
function run_linear_test( N_TESTS, tb_fid ) |
%RUN_LINEAR_TEST Generates a linear test pattern |
% |
% run_linear_test( N, fid ) |
% |
% This function is used to generate linear increasing test |
% values. |
% These values are then processed by the fixed-point YAC |
% implementation. All input and outputs are logged into |
% a testbench pattern file. In addition, the result is plotted. |
% |
% NOTE: only the hyperbolic functions are processed at the moment. |
% This function needs to be extended in future. |
% |
% |
% The argument fid is the file-descriptor of the testbench pattern |
% file. The argument N defines the number of values, which are processed. |
% |
% |
|
data_a_h = ones( 1, N_TESTS ); |
data_b_h = linspace( -1, 1, N_TESTS ) * 0.78; |
data_c_h = linspace( -1, 1, N_TESTS ); |
[ atanh_res, sqrt_res, atanh_err, sqrt_err, it_6 ] = catanh( data_a_h, data_b_h, tb_fid ); |
[ sinh_res, cosh_res, sinh_err, cosh_err, it_7 ] = csinhcosh( data_c_h, tb_fid ); |
|
|
figure; plot( data_b_h, atanh_res ); title( 'atanh' ); |
figure; plot( data_b_h, atanh_err ); title( 'atanh-error' ); |
figure; plot( data_c_h, sinh_res, data_c_h, cosh_res ); title( 'sinh and cosh' ); |
figure; plot( data_c_h, sinh_err, data_c_h, cosh_err ); title( 'sinh and cosh errors' ); |
end |
|
|
|
function run_random_test( N_TESTS, tb_fid ) |
%RUN_RANDOM_TEST Generates a random test pattern |
% |
% run_random_test( N, fid ) |
% |
% This function is used to generate random test |
% values (uniform distributed). |
% These values are then processed by the fixed-point YAC |
% implementation. All input and outputs are logged into |
% a testbench pattern file. |
% |
% |
% The argument fid is the file-descriptor of the testbench pattern |
% file. The argument N defines the number of values, which are processed. |
% |
% |
data_a = -1 + 2 .* rand( 1, N_TESTS ); |
data_b = -1 + 2 .* rand( 1, N_TESTS ); |
data_c = -1 + 2 .* rand( 1, N_TESTS ); |
data_d = -pi + 2*pi .* rand( 1, N_TESTS ); |
% adapat data for division |
data_a_div = data_a; |
data_b_div = data_b; |
swap_div = ( data_b ./ data_a ) >= 2 | ( data_b ./ data_a ) < -2 ; |
data_a_div( swap_div ) = data_b( swap_div ); |
data_b_div( swap_div ) = data_a( swap_div ); |
|
data_a_h = ones( size( data_a ) ); |
data_b_h = data_b .* 0.80694; %0.78; |
|
|
|
[ ~, ~, atan_err, abs_err, it_1 ] = ccart2pol( data_a, data_b, tb_fid ); |
[ ~, ~, sin_err, cos_err, it_2 ] = cpol2cart( data_d, data_b, tb_fid ); |
[ ~, ~, x_err, y_err, it_3 ] = crot( data_a, data_b, data_c, tb_fid ); |
[ ~, div_err, it_4 ] = cdiv( data_a_div, data_b_div, tb_fid ); |
[ ~, mul_err, it_5 ] = cmul( data_a, data_b, tb_fid ); |
[ ~, ~, atanh_err, sqrt_err, it_6 ] = catanh( data_a_h, data_b_h, tb_fid ); |
[ ~, ~, sinh_err, cosh_err, it_7 ] = csinhcosh( data_a, tb_fid ); |
|
print_result_info( atan_err, it_1, ... |
abs_err, it_1, ... |
sin_err, it_2, ... |
cos_err, it_2, ... |
x_err, it_3, ... |
y_err, it_3, ... |
div_err, it_4, ... |
mul_err, it_5, ... |
atanh_err, it_6, ... |
sqrt_err, it_6, ... |
sinh_err, it_7, ... |
cosh_err, it_7, ... |
'Random Value Test' ); |
|
|
end |
|
|
function print_result_info( ... |
atan_err, atan_it, ... |
abs_err, abs_it, ... |
sin_err, sin_it, ... |
cos_err, cos_it, ... |
x_err, x_it, ... |
y_err, y_it, ... |
div_err, div_it, ... |
mul_err, mul_it, ... |
atanh_err, atanh_it, ... |
sqrt_err, sqrt_it, ... |
sinh_err, sinh_it, ... |
cosh_err, cosh_it, ... |
title ) |
|
fprintf( ' ___________________________________________________________________\n' ); |
fprintf( ' %s\n', title); |
fprintf( ' -----+-------------------+--------------------+-------------------\n' ); |
fprintf( ' | max error | mean error | max iterations \n' ); |
fprintf( ' atan | % .14f | % .14f | %.5f \n', max( atan_err ), mean( atan_err ), max( atan_it ) ); |
fprintf( ' abs | % .14f | % .14f | %.5f \n', max( abs_err ), mean( abs_err ), max( abs_it ) ); |
fprintf( ' sin | % .14f | % .14f | %.5f \n', max( sin_err ), mean( sin_err ), max( sin_it ) ); |
fprintf( ' cos | % .14f | % .14f | %.5f \n', max( cos_err ), mean( cos_err ), max( cos_it ) ); |
fprintf( ' x | % .14f | % .14f | %.5f \n', max( x_err ), mean( x_err ), max( x_it ) ); |
fprintf( ' y | % .14f | % .14f | %.5f \n', max( y_err ), mean( y_err ), max( y_it ) ); |
fprintf( ' div | % .14f | % .14f | %.5f \n', max( div_err ), mean( div_err ), max( div_it ) ); |
fprintf( ' mul | % .14f | % .14f | %.5f \n', max( mul_err ), mean( mul_err ), max( mul_it ) ); |
fprintf( ' atanh| % .14f | % .14f | %.5f \n', max( atanh_err ), mean( atanh_err ), max( atanh_it ) ); |
fprintf( ' sqrt | % .14f | % .14f | %.5f \n', max( sqrt_err ), mean( sqrt_err ), max( sqrt_it ) ); |
fprintf( ' sinh | % .14f | % .14f | %.5f \n', max( sinh_err ), mean( sinh_err ), max( sinh_it ) ); |
fprintf( ' cosh | % .14f | % .14f | %.5f \n', max( cosh_err ), mean( cosh_err ), max( cosh_it ) ); |
|
end |
|
|
|
|
|
function [sinh_res, cosh_res, sinh_err, cosh_err, it ]= csinhcosh( th, fid ) |
global C_FLAG_VEC_ROT C_FLAG_ATAN_3 C_MODE_CIRC C_MODE_LIN C_MODE_HYP |
global XY_WIDTH ANGLEWIDTH GUARDBITS RM_GAIN |
|
xi = repmat( (2^(XY_WIDTH-1)-1), size( th ) ); |
yi = zeros( 1, length( th ) ); |
ai = round( th .* (2^(ANGLEWIDTH-1)-1) ); |
|
|
|
mode = C_MODE_HYP; |
|
|
% cordic version |
[ rcosh rsinh ra, it ] = cordic_iterative( ... |
xi, ... |
yi, ... |
ai, ... |
mode, ... |
XY_WIDTH, ... |
ANGLEWIDTH, ... |
GUARDBITS, ... |
RM_GAIN ); |
|
|
|
cosh_res = rcosh ./ ( 2^(XY_WIDTH-1)-1 ); |
sinh_res = rsinh ./ ( 2^(XY_WIDTH-1)-1 ); |
cosh_m = cosh( th ); |
sinh_m = sinh( th ); |
sinh_err = abs(sinh_res - sinh_m ); |
cosh_err = abs(cosh_res - cosh_m ); |
|
|
% write TB data |
write_tb( fid, xi, yi, ai, rcosh, rsinh, ra, mode ); |
|
|
end |
|
|
|
|
|
function [atan_res, abs_res, atan_err, abs_err, it ] = catanh( x, y, fid ) |
global C_FLAG_VEC_ROT C_FLAG_ATAN_3 C_MODE_CIRC C_MODE_LIN C_MODE_HYP |
global XY_WIDTH ANGLEWIDTH GUARDBITS RM_GAIN |
|
if( size( x ) ~= size( y ) ) |
error( 'size error' ) |
end |
ai = zeros( size( x ) ); |
xi = round( x * (2^(XY_WIDTH-1)-1) ); |
yi = round( y * (2^(XY_WIDTH-1)-1) ); |
|
|
mode = C_FLAG_VEC_ROT + C_MODE_HYP; |
|
|
% cordic version |
[ rx, ry, ra, it ] = cordic_iterative( xi, ... |
yi, ... |
ai, ... |
mode, ... |
XY_WIDTH, ... |
ANGLEWIDTH, ... |
GUARDBITS, ... |
RM_GAIN ); |
% matlab version |
m_th = atanh( y ./ x ); |
m_r = sqrt( x.^2 - y.^2 ); |
|
% comparison |
atan_res = ra ./ 2^( (ANGLEWIDTH)-1); |
abs_res = rx ./ ( 2^(XY_WIDTH-1) -1 ); |
atan_err = abs( m_th - atan_res ); |
abs_err = abs( m_r - abs_res ); |
|
% write TB data |
write_tb( fid, xi, yi, ai, rx, ry, ra, mode ); |
|
|
end |
|
|
|
|
|
function [mul_res, mul_err, it ] = cmul( x, y, fid ) |
global C_FLAG_VEC_ROT C_FLAG_ATAN_3 C_MODE_CIRC C_MODE_LIN C_MODE_HYP |
global XY_WIDTH ANGLEWIDTH GUARDBITS RM_GAIN |
|
if( size( x ) ~= size( y ) ) |
error( 'size error' ) |
end |
xi = round( x * ( 2^(XY_WIDTH-1) -1 ) ); |
ai = round( y * ( 2^(XY_WIDTH-1) -1 ) ); |
yi = zeros( size( x ) ); |
|
|
mode = C_MODE_LIN; |
|
% cordic version |
[ rx, rmul, ra, it ] = cordic_iterative( xi, ... |
yi, ... |
ai, ... |
mode, ... |
XY_WIDTH, ... |
ANGLEWIDTH, ... |
GUARDBITS, ... |
RM_GAIN ); |
|
|
mul_res = rmul ./ (2^(ANGLEWIDTH-1)-1); |
mul_err = abs( y.*x - mul_res ); |
|
% write TB data |
write_tb( fid, xi, yi, ai, rx, rmul, ra, mode ) |
|
|
end |
|
|
|
|
|
function [div_res, div_err, it ] = cdiv( x, y, fid ) |
global C_FLAG_VEC_ROT C_FLAG_ATAN_3 C_MODE_CIRC C_MODE_LIN C_MODE_HYP |
global XY_WIDTH ANGLEWIDTH GUARDBITS RM_GAIN |
|
if( size( x ) ~= size( y ) ) |
error( 'size error' ) |
end |
xi = round( x * ( 2^(XY_WIDTH-1) -1 ) ); |
yi = round( y * ( 2^(XY_WIDTH-1) -1 ) ); |
ai = zeros( size( x ) ); |
|
|
mode = C_FLAG_VEC_ROT + C_MODE_LIN; |
|
% cordic version |
[ rx, ry, rdiv, it ] = cordic_iterative( xi, ... |
yi, ... |
ai, ... |
mode, ... |
XY_WIDTH, ... |
ANGLEWIDTH, ... |
GUARDBITS, ... |
RM_GAIN ); |
|
|
div_res = rdiv ./ (2^(ANGLEWIDTH-1)-1); |
div_err = abs( y./x - div_res ); |
|
% write TB data |
write_tb( fid, xi, yi, ai, rx, ry, rdiv, mode ) |
|
end |
|
|
function [x_res, y_res, x_err, y_err, it ] = crot( x, y, th, fid ) |
% |
% does a multiplication with exp( th * i ) |
% and therefore, a rotation of the complex input value x + yi where th |
% defines the rotation angle |
% |
global C_FLAG_VEC_ROT C_FLAG_ATAN_3 C_MODE_CIRC C_MODE_LIN C_MODE_HYP |
global XY_WIDTH ANGLEWIDTH GUARDBITS RM_GAIN |
|
xi = round( x * ( 2^(XY_WIDTH-1) -1 ) ); |
yi = round( y * ( 2^(XY_WIDTH-1) -1 ) ); |
ai = round( th .* (2^(ANGLEWIDTH-1)-1) ); |
|
mode = C_MODE_CIRC; |
|
[ rx ry ra, it ] = cordic_iterative( ... |
xi, ... |
yi, ... |
ai, ... |
mode, ... |
XY_WIDTH, ... |
ANGLEWIDTH, ... |
GUARDBITS, ... |
RM_GAIN ); |
|
tmp = ( x + 1i * y ) .* exp( i * th ); |
|
x_res = rx ./ ( 2^(XY_WIDTH-1)-1 ); |
y_res = ry ./ ( 2^(XY_WIDTH-1)-1 ); |
|
y_err = abs(x_res - real(tmp) ); |
x_err = abs(y_res - imag(tmp) ); |
|
% write TB data |
write_tb( fid, xi, yi, ai, rx, ry, ra, mode ) |
|
|
end |
|
|
function [sin_res, cos_res, sin_err, cos_err, it ]= cpol2cart( th, r, fid ) |
% |
% does the Matlab equivalent pol2cart |
% |
|
global C_FLAG_VEC_ROT C_FLAG_ATAN_3 C_MODE_CIRC C_MODE_LIN C_MODE_HYP |
global XY_WIDTH ANGLEWIDTH GUARDBITS RM_GAIN |
|
xi = r .* (2^(XY_WIDTH-1)-1); |
yi = zeros( 1, length( th ) ); |
ai = round( th .* (2^(ANGLEWIDTH-1)-1) ); |
|
mode = C_MODE_CIRC; |
|
[ rcos rsin ra, it ] = cordic_iterative( ... |
xi, ... |
yi, ... |
ai, ... |
mode, ... |
XY_WIDTH, ... |
ANGLEWIDTH, ... |
GUARDBITS, ... |
RM_GAIN ); |
|
|
|
cos_res = rcos ./ ( 2^(XY_WIDTH-1)-1 ); |
sin_res = rsin ./ ( 2^(XY_WIDTH-1)-1 ); |
[ cos_m, sin_m ] = pol2cart( th, r ); |
sin_err = abs(sin_res - sin_m ); |
cos_err = abs(cos_res - cos_m ); |
|
% write TB data |
write_tb( fid, xi, yi, ai, rcos, rsin, ra, mode ) |
|
|
end |
|
|
|
|
|
function [atan_res, abs_res, atan_err, abs_err, it ] = ccart2pol( x, y, fid ) |
|
global C_FLAG_VEC_ROT C_FLAG_ATAN_3 C_MODE_CIRC C_MODE_LIN C_MODE_HYP |
global XY_WIDTH ANGLEWIDTH GUARDBITS RM_GAIN |
|
if( size( x ) ~= size( y ) ) |
error( 'size error' ) |
end |
ai = zeros( size( x ) ); |
xi = round( x * (2^(XY_WIDTH-1)-1) ); |
yi = round( y * (2^(XY_WIDTH-1)-1) ); |
|
|
mode = C_FLAG_VEC_ROT + C_MODE_CIRC; |
|
|
% cordic version |
[ rx, ry, ra, it ] = cordic_iterative( xi, ... |
yi, ... |
ai, ... |
mode, ... |
XY_WIDTH, ... |
ANGLEWIDTH, ... |
GUARDBITS, ... |
RM_GAIN ); |
% matlab version: |
m_th = atan2( y, x ); |
m_r = sqrt( x.^2 + y.^2 ); |
|
|
% comparison |
atan_res = ra ./ 2^( (ANGLEWIDTH)-1); |
abs_res = rx ./ ( 2^(XY_WIDTH-1) -1 ); |
atan_err = abs( m_th - atan_res ); |
abs_err = abs( m_r - abs_res ); |
|
% TODO: ATAN oder ATAN2 atan( 0 / x ) != atan2( 0, x )!!!! |
|
% write TB data |
write_tb( fid, xi, yi, ai, rx, ry, ra, mode ) |
|
end |
|
|
|
|
|
function write_tb( fid, x_i, y_i, a_i, x_o, y_o, a_o, mode ) |
|
if fid > 0 |
for x = 1 : length( x_i ) |
fprintf( fid, '%ld ', fix( [ x_i(x), y_i(x), a_i(x), x_o(x), y_o(x), a_o(x), mode ] ) ); |
fprintf( fid, '\n' ); |
end |
end |
|
end |
/trunk/doc/documentation.pdf
Cannot display: file marked as a binary type.
svn:mime-type = application/pdf
trunk/doc/documentation.pdf
Property changes :
Added: svn:mime-type
## -0,0 +1 ##
+application/pdf
\ No newline at end of property
Index: trunk/doc/documentation.tex
===================================================================
--- trunk/doc/documentation.tex (nonexistent)
+++ trunk/doc/documentation.tex (revision 2)
@@ -0,0 +1,507 @@
+\documentclass[a4paper, 12pt, notitlepage]{report}
+
+\usepackage{amsfonts}
+\usepackage{graphicx}
+\usepackage{fullpage}
+\usepackage[pagewise]{lineno}
+\usepackage{hyperref}
+\usepackage{longtable}
+\usepackage{ltxtable}
+\usepackage[usenames,dvipsnames]{color}
+\usepackage{colortbl}
+\usepackage{tabularx, booktabs}
+\usepackage{multirow}
+\usepackage{dirtree}
+\definecolor{tableheadcolor}{gray}{0.8}
+\definecolor{darkblue}{rgb}{0,0,.5}
+\definecolor{gray}{gray}{0.95}
+\definecolor{lightgray}{gray}{0.95}
+\newcommand{\file}[1]{\textbf{#1}}
+\newcommand{\state}[1]{{\tt\textbf{#1}}}
+\newcommand{\signal}[1]{{\textbf{\tt#1}}}
+\title{YAC - Yet Another CORDIC Core}
+\author{Christian Haettich [feddischson@opencores.org]}
+\date{\today}
+
+\begin{document}
+
+%%%%%%%%%% PRELIMINARY MATERIAL %%%%%%%%%%
+\maketitle
+\begin{center}
+IP core and C-model documentation
+\end{center}
+\thispagestyle{empty}
+
+\tableofcontents
+
+
+\chapter{Organization and Introduction}
+\section{History}
+\begin{table}[htbp]
+ \center
+ \begin{tabular}{@{}llll@{}}
+ \rowcolor{tableheadcolor}\textbf{Version}& \textbf{Date} & \textbf{Description} & \textbf{Author} \\
+
+ \multirow{1}{*}{0.01} & 4th March 2014 & Initial document & Christian Haettich\\\midrule
+ \bottomrule
+ \end{tabular}
+ \caption{History}
+ \label{tab:frqband}
+\end{table}
+
+
+\section{Folder and Files}
+
+\dirtree{%
+.1 /.
+.2 c\_octave.
+.3 cordic\_iterative.c\DTcomment{C-code for bit accurate model}.
+.3 cordic\_iterative\_code.m\DTcomment{Script to auto-generate VHDL and C-code}.
+.3 cordic\_iterative\_test.m\DTcomment{YAC performance analysis script}.
+.2 doc.\DTcomment{Contains files to create this documentation}.
+.2 licenses.
+.3 lgpl-3.0.txt\DTcomment{LGPL license}.
+.2 README.txt\DTcomment{A short read-me file}.
+.2 rtl.
+.3 vhdl.
+.4 cordic\_iterative\_int.vhd\DTcomment{Top-level VHDL file}.
+.4 cordic\_iterative\_pkg.vhd\DTcomment{VHDL package file}.
+.4 cordic\_iterative\_tb.vhd\DTcomment{VHDL testbench}.
+}
+
+\section{License}
+Copyright (c) 2014, Christian Haettich, All rights reserved. \newline\newline
+YAC is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version. \newline\newline
+YAC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details. \newline\newline
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, download it from
+http://www.gnu.org/licenses/lgpl
+
+
+\section{The CORDIC algorithm}
+
+The CORDIC algorithm is used to do trigonometric, hyperbolic, multiplication
+and division calculations in a hardware-efficient way. This means, that
+only bit-shift, addition and subtraction operations in combination
+with a lookup-table is required.\newline
+Good introductions are available in \cite{survey}\cite{vlsi}\cite{dawid}.
+A description on wikibook.org \cite{wikibook} is also useful.
+For this reason, no more introduction is given here and the following chapters assume, that
+the reader is familiar with the CORDIC algorithm.
+
+
+\chapter{IP-Core Description}
+
+The two files \file{cordic\_iterative\_int.vhd} and \file{cordic\_iterative\_pkg.vhd}
+implements an iterative CORDIC algorithm in fixed-point format.
+Iterative means, that the IP-core is started with a set of input data and after
+a specific amount of clock cycles, the result is available. No parallel data
+can be processed. The
+following six modes are supported:
+\begin{itemize}
+ \item trigonometric rotation
+ \item trigonometric vectoring
+ \item linear rotation
+ \item linear vectoring
+ \item hyperbolic rotation
+ \item hyperbolic vectoring
+\end{itemize}
+
+\section{Port Description}
+\begin{table}[htbp]
+ \center
+ \begin{tabular}{@{}lllll@{}}
+ \rowcolor{tableheadcolor}\textbf{Name}& \textbf{Type} & \textbf{Direction} & \textbf{Size} & \textbf{Description} \\
+
+ \multirow{1}{*}{clk} & std\_logic & input & 1 & clock \\\midrule
+ \multirow{1}{*}{rst} & std\_logic & input & 1 & synchronous reset \\\midrule
+ \multirow{1}{*}{en} & std\_logic & input & 1 & clock-enable \\\midrule
+ \multirow{1}{*}{start} & std\_logic & input & 1 & start trigger \\\midrule
+ \multirow{1}{*}{done} & std\_logic & output & 1 & done indicator \\\midrule
+ \multirow{1}{*}{mode} & std\_logic\_vector & input & 4 & mode configuration \\\midrule
+ \multirow{1}{*}{x\_i} & std\_logic\_vector & input & XY\_WIDTH & X input vector \\\midrule
+ \multirow{1}{*}{y\_i} & std\_logic\_vector & input & XY\_WIDTH & Y input vector \\\midrule
+ \multirow{1}{*}{a\_i} & std\_logic\_vector & input & A\_WIDTH + 2 & angular input vector \\\midrule
+ \multirow{1}{*}{x\_o} & std\_logic\_vector & input & XY\_WIDTH + GUARD\_BITS & X output vector \\\midrule
+ \multirow{1}{*}{y\_o} & std\_logic\_vector & input & XY\_WIDTH + GUARD\_BITS & Y output vector \\\midrule
+ \multirow{1}{*}{a\_o} & std\_logic\_vector & input & A\_WIDTH + 2 & angular output vector \\\midrule
+ \bottomrule
+ \end{tabular}
+ \caption{Port description}
+ \label{tab:ports}
+\end{table}
+
+\begin{figure}[p]
+\centering
+ \includegraphics{figs/block_symbol.pdf}
+ \caption{YAC block symbol}
+ \label{fig:ports}
+\end{figure}
+Table \ref{tab:ports} and Figure \ref{fig:ports} gives an overview
+of the YAC ports.
+The three input ports start, done and mode and are used to interact
+with an external state machine or with a software driver.
+After setting \signal{start} to high, the YAC starts processing.
+If all necessary rotations are done, the \signal{done} output is set to
+high for one clock cycle.
+When starting the YAC, all other inputs must contain valid data.
+The mode input is used to select the CORDIC mode.
+Table \ref{fig:ports} shows all input and output ports and Figure
+\ref{fig:ports} shows a CORDIC block symbol: $x_i, y_i, a_i, x_o, y_o, a_o$
+are data ports whereas start, done and mode are configuration signals.
+
+
+
+
+
+
+\section{Parameter Description}
+\begin{table}[htbp]
+ \center
+ \begin{tabular}{@{}lllll@{}}
+ \rowcolor{tableheadcolor}\textbf{Name}& \textbf{type} & \textbf{size} & \textbf{Description} \\
+
+ \multirow{1}{*}{XY\_WIDTH} & natural & defines the size of x and y input and output vectors \\\midrule
+ \multirow{1}{*}{A\_WIDTH} & natural & defines the size of the angular input and output vectors \\\midrule
+ \multirow{1}{*}{GUARD\_BITS} & natural & defines the number of guard bits \\\midrule
+ \multirow{1}{*}{RM\_GAIN} & natural & defines the precision of the CORDIC gain removal \\\midrule
+ \bottomrule
+ \end{tabular}
+ \caption{Parameter description}
+ \label{tab:params}
+\end{table}
+Table \ref{tab:params} shows the four parameter, which can be used to parameterize
+the YAC.
+
+
+\section{Mode description}
+With the mode-input, it is possible to select between circular, linear and hyperbolic
+operation as well as between rotation and vectoring operations:
+\begin{itemize}
+\item mode(1:0) = "00" selects circular operation
+\item mode(1:0) = "01" selects linear operation
+\item mode(1:0) = "10" selects hyperbolic operation
+\item mode(1:0) = "11" is reserved
+\item mode(3) = '0' selects rotation
+\item mode(3) = '1' selects vectoring
+\end{itemize}
+The package cordic\_iterative\_int.vhd contains the following defines to
+setup the mode:
+\begin{itemize}
+ \item VAL\_MODE\_CIRC = "00"
+ \item VAL\_MODE\_LIN = "01"
+ \item VAL\_MODE\_HYP = "10"
+ \item I\_FLAG\_VEC\_ROT = 3 (bit index)
+\end{itemize}
+For example if a hyperbolic rotation mode is required, the mode input is "0010",
+and for the linear vector operation, the mode input is "1001".
+Please note, that bit number 2 is reserved for future implementations.\newline
+Table \ref{tab:modes} defines the behaviour of the YAC
+for different mode configurations.
+\begin{table}[htbp]
+ \center
+ \begin{tabular}{@{}ll@{}}
+ \rowcolor{tableheadcolor}\textbf{Setup}& \textbf{Description} \\
+
+ \multirow{2}{*}{mode =( FLAG\_VEC\_ROT = 1, VAL\_MODE\_CIR ) } & $a_o = \textrm{atan2}( y_i, x_i ) \cdot \beta, $\\
+ & $x_o = \sqrt{ x_i^2+y_i^2 } $ \\\midrule
+ \multirow{2}{*}{mode =( FLAG\_VEC\_ROT = 0, VAL\_MODE\_CIR ) } & $x_o = \cos( a_i / \beta ) \cdot \alpha $\\
+ & $y_o = \sin( a_i / \beta ) \cdot \alpha $\\\midrule
+ \multirow{1}{*}{mode =( FLAG\_VEC\_ROT = 1, VAL\_MODE\_LIN ) } & $a_o = z + y/x $\\\midrule
+ \multirow{1}{*}{mode =( FLAG\_VEC\_ROT = 0, VAL\_MODE\_LIN ) } & $a_o = y + x\cdot z $ $ $\\\midrule
+ \multirow{2}{*}{mode =( FLAG\_VEC\_ROT = 1, VAL\_MODE\_HYP ) } & $a_o = \textrm{tanh}( y_i / x_i ) \cdot \beta, $\\
+ & $x_o = \sqrt{ x_i^2-y_i^2 } $\\\midrule
+ \multirow{2}{*}{mode =( FLAG\_VEC\_ROT = 0, VAL\_MODE\_HYP ) } & $x_o = \cosh( a_i / \beta ) \cdot \alpha$\\
+ & $y_o = \sinh( a_i / \beta ) \cdot \alpha$\\
+ \bottomrule
+ \end{tabular}
+ \caption{Mode description (see equation \ref{eqn:alpha} and \ref{eqn:beta} for $\alpha$ and $\beta$)}
+ \label{tab:modes}
+\end{table}
+
+
+\section{Data Range and Limitations}
+
+ Both, the $x_i$ and $y_i$ inputs are defined with a size of $XY\_WIDTH$ and therefore,
+ the maximum positive value in the two's complement format is
+ \begin{eqnarray}
+ \alpha & = & 2^{XY\_WIDTH-1}-1
+ \label{eqn:alpha}
+ \end{eqnarray}
+ The angle input $a_i$ is defined with a size of $A\_WIDTH+2$.
+ The value $\beta$ is defined with
+ \begin{eqnarray}
+ \beta & = & 2^{A\_WIDTH-1} -1
+ \label{eqn:beta}
+ \end{eqnarray}
+
+ \subsection{Circular Vectoring Mode}
+
+ The valid input range for $x_i$ and $y_i$ is $-\alpha ... +\alpha$.
+ The angular input $a_i$ is ignored.
+
+ \subsection{Circular Rotation Mode}
+ The valid input range for $x_i$ and $y_i$ is $-\alpha ... +\alpha$.
+ For the angular input $a_i$, values between $-\beta\pi$ and $+\beta\pi$ are valid.
+ For calculating a complex rotation of a complex vector, all three inputs
+ are required. For calculating $\sin$ and $\cos$, $x_i$ is set to $\alpha$
+ and $y_i$ to 0, the angle input $a_i$ gets the angle.
+
+ \subsection{Linear Vectoring Mode}
+ The linear vectoring mode is used to calculate $y_i / x_i$. The limitation
+ of this operation is the following:
+ \begin{eqnarray}
+ \frac{y_i}{x_i} \le 2
+ \end{eqnarray}
+ The valid input values for $x_i$ and $y_i$ are $-\alpha ... +\alpha$.
+
+ \subsection{Linear Rotation Mode}
+ The two inputs $x_i$ and $y_i$ have a valid data range between $-\alpha$ and $+\alpha$.
+
+
+ \subsection{Hyperbolic Vectoring Mode}
+ The data-range for $x_i$ and $y_i$ is $-0.79 \cdot \alpha$ to $0.79 \cdot \alpha$.
+
+
+ \subsection{Hyperbolic Rotation Mode}
+ The data-range for $a_i$ is $-\beta ... \beta$. Typically, $x_i$ is set to
+ $\alpha$ and $y_i$ to 0.
+
+\section{Internal Operation}
+\begin{figure}[p]
+\centering
+ \includegraphics[width=200pt]{figs/state_diagram.pdf}
+ \caption{State diagram}
+ \label{fig:states}
+\end{figure}
+Five states are used do to the CORDIC algorithm. The five states are visualized in a
+state diagram in Figure \ref{fig:states}.
+After reset, the YAC goes into the \state{ST\_IDLE} state. Only in this state, the
+start signal is accepted. After starting the YAC, the state switches from
+the \state{ST\_IDLE} state to the \state{ST\_INIT} state. The init state does some initial
+rotations/flipping.
+After initialization, the main rotation starts with the \state{ST\_ROTATION} state
+(there are a few cases, where no further rotations are required, see next sections).
+Every rotation step is done within two clock cycles: in the first cycle,
+the angular value is loaded from the lookup-table and shifted. In addition,
+the x and y values are shifted. In the second
+clock cycle, the results are added according to the CORDIC algorithm.
+After all required iterations are done, the state switches to
+the \state{RM\_GAIN} state, where the CORDIC gain is removed (depending on
+the mode). The last state \state{ST\_DONE} is only used to set the done flag to
+'1' for one clock cycle. After this, the YAC returns to the \state{ST\_IDLE} state.
+
+
+
+ \subsection{Initialization}
+ During the initialization state ST\_INIT, pre-rotations are done, depending on
+ the selected mode.
+
+
+ \subsubsection{Circular Vectoring Mode}
+ Because we support atan2 and not atan, we do the following pre-rotations.
+ Some specific input values don't need a further processing, for
+ example $atan( 0, 0 )$.\newline\newline
+ \begin{tabular}{@{}lp{380pt}@{}}
+ \rowcolor{tableheadcolor}\textbf{Input} &\textbf{ Description } \\
+
+ $x_i = 0, y_i = 0$ & Fixed result: $x_o = 0, a_o = 0$,
+ to support cartesian to polar coordinate transformations,
+ further processing is skipped \\ \midrule
+
+ $x_i = 0, y_i > 0 $ & Fixed result: $x_o = y_i, a_o = \pi/2$,
+ further processing is skipped \\ \midrule
+
+ $x_i = 0, y_i < 0 $ & Fixed result: $x_o = -y_i, a_o = -\pi/2$,
+ further processing is skipped \\ \midrule
+
+
+ $x_i < 0, y_i < 0 $ & Pre-rotation from the third to the first quadrant,
+ the angular register is initialized with $-\pi$ and
+ the sign of the $x$ and $y$ register is flipped. \\ \midrule
+
+ $x_i < 0, y_i \ge 0 $ & Pre-rotation from the second to the fourth quadrant,
+ the angular register is initialized with $\pi$ and
+ the sign of the $x$ and $y$ register is flipped. \\ \midrule
+
+
+ $x_i = + \alpha, y_i = + \alpha $ & Fixed result: $x_o = \sqrt{2} \cdot \alpha, a_o = \frac{\pi}{4} \cdot \beta$ ,
+ further processing is skipped \\ \midrule
+
+ $x_i = + \alpha, y_i = - \alpha $ & Fixed result: $x_o = \sqrt{2} \cdot \alpha, a_o = - \frac{\pi}{4} \cdot \beta$,
+ further processing is skipped \\ \midrule
+
+ $x_i = - \alpha, y_i = + \alpha $ & Fixed result: $x_o = \sqrt{2} \cdot \alpha, a_o = \frac{3 \pi}{4} \cdot \beta$,
+ further processing is skipped \\ \midrule
+
+ $x_i = - \alpha, y_i = - \alpha $ & Fixed result: $x_o = \sqrt{2} \cdot \alpha, a_o = - \frac{3 \pi }{4} \cdot \beta$ ,
+ further processing is skipped \\
+ \bottomrule
+ \end{tabular}
+
+ \subsubsection{Circular Rotation Mode}
+ The following pre-rotations are done:\newline\newline
+ \begin{tabular}{@{}lp{380pt}@{}}
+ \rowcolor{tableheadcolor}\textbf{Input} &\textbf{ Description } \\
+
+ $a_i < - \frac{\pi}{2}$ & Pre-rotation from the third to the first quadrant,
+ the sign of the $x$ and $y$ register is flipped,
+ the angular register is initialized with $\pi$ \\ \midrule
+
+ $a_i > \frac{\pi}{2}$ & Pre-rotation from the second to the fourth quadrant,
+ the sign of the $x$ and $y$ register is flipped,
+ the angular register is initialized with $-\pi$ \\
+ \bottomrule
+ \end{tabular}
+
+ \subsubsection{Linear Vectoring Mode}
+ The following pre-rotations are done:\newline\newline
+ \begin{tabular}{@{}lp{380pt}@{}}
+ \rowcolor{tableheadcolor}\textbf{Input} &\textbf{ Description } \\
+
+ $x_i < 0$ & Pre-rotation from the left half to the right half, thus
+ the sign of the $x$ and $y$ register is flipped \\
+ \bottomrule
+ \end{tabular}
+
+
+ \subsection{Rotation}
+
+ \subsubsection{Hyperbolic Repetitions}
+ The following iteration steps are repeated for convergence of the hyperbolic mode:
+ \begin{eqnarray}
+ 4, 13, 40, 121, ..., 3i+1
+ \end{eqnarray}
+
+
+
+\section{Testbench}
+A VHDL testbench (cordic\_iterative\_tb.vhd) is available which reads from an input file
+data. This data is fed into the YAC. In addition, the input file must
+provide the output data, which is expected from the YAC processing.
+The following format is used in the testbench input-file:
+\begin{verbatim}
+x_i y_i a_i x_o y_o a_o mode
+
+1234 1234 1234 1234 1234 1234 111 \
+2345 2345 2345 2345 2345 2345 222 | 7 columns:
+3456 3456 3456 3456 3456 3456 333 | 3 input, 3 output and one mode
+... ... |
+... |
+...
+\end{verbatim}
+The data must be in the two's complement with a base of 10.
+After processing all lines, the testbench prints some info, how much
+tests failed.\newline
+For generating the test-patterns, the C-model with octave is used. By running
+the script \file{cordic\_iterative\_test.m}, an entry
+in the testbech data file is done for every cordic calculation.
+
+
+\chapter{Using the C-Model with Octave or Matlab}
+For using the C-model, open octave or Matlab and compile the C-Model
+with \newline
+\textit{mex cordic\_iterative.c}
+Afterwards, the C-model can be used in Octave/Matlab with the function call\newline
+{\tt [ x\_o, y\_o, a\_o, it ] = cordic\_iterative( x\_i, y\_i, a\_i, mode, XY\_WIDTH, ANGLE\_WIDTH,
+GUARD\_BITS, RM\_GAIN )}.\newline
+The input and output arguments reflect almost the ports and parameters of the
+VHDL toplevel implementation, except that there is no done, start clk and rst port
+in the C-model. In addition, the last argument provides the number of iterations,
+which are done.\newline \newline
+The input arguments x\_i, y\_i, and a\_i can be 1xN vectors with N elements.
+In this case, this three input arguments must have the same size. All
+output arguments will also have the same size 1xN.
+
+
+
+\section{Guard-Bits -- Input and output sizes}
+It is possible to define MSB guard bits.
+The need of MSB guard bits have several reasons. On the one hand,
+they are required to handle the data growth of the cordic gain within the rotation state.
+(which is compensated later). A nother reason is the data growth caused by the choise of
+input data. For example
+\begin{eqnarray}
+ \sqrt{ \alpha^2 + \alpha^2 } = \sqrt{2} \alpha
+\end{eqnarray}
+and therefore, a growth by the factor $\sqrt{2}$ happens, if an absolute calculation
+of the two maximum input values is processed.\newline
+\newline
+Another point is the input and output size of the angular values ($a_i$ and $a_o$)
+Because within this YAC, $\beta$ represents the angle 1, the input and output with
+of $a_i$ and $a_o$ is A\_WIDTH+2, which allows to process angle values within
+$-\pi ... \pi$
+
+
+\subsection{Input data width versus iterations}
+The number of iterations depends on the width of the input data.
+Input data with $X$ bit require $X+1$ rotations \cite{dawid}.
+This requires, that the number of iterations are adapted. One solution might
+be to detect the size of the input data and use this information for the CORDIC processing.
+In YAC, a different sheme was chosen: the rotations are done until
+\begin{itemize}
+ \item the angular register is 0 or doesn't change (in case of the rotation mode)
+ \item the y register is 0 or doesn't change (in case of the vecotring mode).
+\end{itemize}
+This results in a dynamic iterations adaption, depending the the input data width.
+
+\chapter{Performance}
+The performance is evaluated through the matlab script \file{cordic\_iterative\_test.m}.
+
+
+\chapter{Open issues and future work}
+
+ \section{Next steps}
+ \begin{itemize}
+ \item Add YAC to a FPGA based System-on-Chip to prove
+ FPGA feasibility
+ \item Performance optimization
+ \item circuit optimizations
+ \item numerical optimizations
+ \end{itemize}
+
+ \section{Future plans}
+ \begin{itemize}
+ \item Hyperbolic range extension
+ \item Floating point CORDIC
+ \end{itemize}
+
+
+
+%%%%%%%%%% BIBLIOGRAPHY %%%%%%%%%%
+\begin{thebibliography}{9}
+
+\bibitem{survey}
+ Andraka, Ray; \textit{A survey of CORDIC algorithms for FPGA based computers}
+
+\bibitem{vlsi}
+ Hu, Yu Hen; \textit{CORDIC-Based VLSI Architectures for Digital Signal Processing}
+
+\bibitem{wikibook}
+ CORDIC on wikibook: \url{http://en.wikibooks.org/wiki/Digital_Circuits/CORDIC}
+
+\bibitem{dawid}
+ David, Herbert; Meyr, Heinricht; \textit{CORDIC Algorithms and Architectures}
+ \url{http://www.eecs.berkeley.edu/newton/Classes/EE290sp99/lectures/ee290aSp996_1/cordic_chap24.pdf}
+\end{thebibliography}
+\end{document}
+
+
+%
+%
+% Opencores Description
+%
+% For this project GIT is preferred as revision control and therefore, the files under development are located on https://github.com/feddischson/yac.
+% Nevertheless, stable intermediate steps are place here on SVN.
+%
+%
+%
+%
+%
+%
Index: trunk/licenses/lgpl-3.0.txt
===================================================================
--- trunk/licenses/lgpl-3.0.txt (nonexistent)
+++ trunk/licenses/lgpl-3.0.txt (revision 2)
@@ -0,0 +1,165 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+ This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+ 0. Additional Definitions.
+
+ As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+ "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+ An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+ A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+ The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+ The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+ 1. Exception to Section 3 of the GNU GPL.
+
+ You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+ 2. Conveying Modified Versions.
+
+ If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+ a) under this License, provided that you make a good faith effort to
+ ensure that, in the event an Application does not supply the
+ function or data, the facility still operates, and performs
+ whatever part of its purpose remains meaningful, or
+
+ b) under the GNU GPL, with none of the additional permissions of
+ this License applicable to that copy.
+
+ 3. Object Code Incorporating Material from Library Header Files.
+
+ The object code form of an Application may incorporate material from
+a header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+ a) Give prominent notice with each copy of the object code that the
+ Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the object code with a copy of the GNU GPL and this license
+ document.
+
+ 4. Combined Works.
+
+ You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+ a) Give prominent notice with each copy of the Combined Work that
+ the Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the Combined Work with a copy of the GNU GPL and this license
+ document.
+
+ c) For a Combined Work that displays copyright notices during
+ execution, include the copyright notice for the Library among
+ these notices, as well as a reference directing the user to the
+ copies of the GNU GPL and this license document.
+
+ d) Do one of the following:
+
+ 0) Convey the Minimal Corresponding Source under the terms of this
+ License, and the Corresponding Application Code in a form
+ suitable for, and under terms that permit, the user to
+ recombine or relink the Application with a modified version of
+ the Linked Version to produce a modified Combined Work, in the
+ manner specified by section 6 of the GNU GPL for conveying
+ Corresponding Source.
+
+ 1) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (a) uses at run time
+ a copy of the Library already present on the user's computer
+ system, and (b) will operate properly with a modified version
+ of the Library that is interface-compatible with the Linked
+ Version.
+
+ e) Provide Installation Information, but only if you would otherwise
+ be required to provide such information under section 6 of the
+ GNU GPL, and only to the extent that such information is
+ necessary to install and execute a modified version of the
+ Combined Work produced by recombining or relinking the
+ Application with a modified version of the Linked Version. (If
+ you use option 4d0, the Installation Information must accompany
+ the Minimal Corresponding Source and Corresponding Application
+ Code. If you use option 4d1, you must provide the Installation
+ Information in the manner specified by section 6 of the GNU GPL
+ for conveying Corresponding Source.)
+
+ 5. Combined Libraries.
+
+ You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+ a) Accompany the combined library with a copy of the same work based
+ on the Library, uncombined with any other library facilities,
+ conveyed under the terms of this License.
+
+ b) Give prominent notice with the combined library that part of it
+ is a work based on the Library, and explaining where to find the
+ accompanying uncombined form of the same work.
+
+ 6. Revised Versions of the GNU Lesser General Public License.
+
+ The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+ If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
Index: trunk/README.txt
===================================================================
--- trunk/README.txt (nonexistent)
+++ trunk/README.txt (revision 2)
@@ -0,0 +1,120 @@
+----------------------------------------------------------------------------
+---- ----
+---- Copyright Notice ----
+---- ----
+---- This file is part of YAC - Yet Another CORDIC Core ----
+---- Copyright (c) 2014, Author(s), All rights reserved. ----
+---- ----
+---- YAC is free software; you can redistribute it and/or ----
+---- modify it under the terms of the GNU Lesser General Public ----
+---- License as published by the Free Software Foundation; either ----
+---- version 3.0 of the License, or (at your option) any later version. ----
+---- ----
+---- YAC is distributed in the hope that it will be useful, ----
+---- but WITHOUT ANY WARRANTY; without even the implied warranty of ----
+---- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ----
+---- Lesser General Public License for more details. ----
+---- ----
+---- You should have received a copy of the GNU Lesser General Public ----
+---- License along with this library. If not, download it from ----
+---- http://www.gnu.org/licenses/lgpl ----
+---- ----
+----------------------------------------------------------------------------
+
+
+
+ Author(s): Christian Haettich
+ Email feddischson@opencores.org
+
+
+
+
+
+
+Description
+------------------
+
+CORDIC is the acronym for COordinate Rotation DIgital Computer and
+allows a hardware efficient calculation of various functions
+like - atan, sin, cos - atanh, sinh, cosh, - division, multiplication.
+Hardware efficient means, that only shifting, additions and
+subtractions in combination with table-lookup is required. This makes
+it suitable for a realization in digital hardware. Good
+introductions can be found in [1][2][3][5].
+
+
+
+The following six CORDIC modes are supported:
+- trigonometric rotation
+- trigonometric vectoring
+- linear rotation
+- linear vectoring
+- hyperbolic rotation
+- hyperbolic vectoring
+
+
+Furthermore, the CORDIC algorithm is implemented for iterative
+processing which means, that the IP-core is started
+with a set of input data and after a specific amount of
+clock cycles, the result is
+available. No parallel data can be processed.
+
+In addition to an IP-core written in VHDL, a bit-accurate C-model
+is provided. This C-model can be compiled as mex for a usage with Octave or
+Matlab. Therefore, this C-model allows a bit-accurate analysis
+of the CORDIC performance on a higher level.
+
+
+For a more detailed documentation, see ./doc/documentation.pdf
+
+
+
+
+
+Status
+----------------------
+- C-model implementation is done
+- RTL model implementation is done
+- RTL model is verified against C-model
+
+
+
+
+
+Next-Steps
+-----------------------
+- Prove of FPGA feasibility
+- Circuit optimizations
+- Numerical optimizations
+
+
+
+
+
+Files and folders:
+------------------
+
+ ./c_octave : contains a bit-accurate C-implementation of the YAC.
+ This C-implementation is used for analyzing the performance
+ and to generate RTL testbench stimulus
+ (cordic_iterative_test.m).
+ The file cordic_iterative_code.m is used to create some
+ VHDL/C-code automatically.
+
+ ./rtl/vhdl : Contains the VHDL implementation files
+
+ ./doc : Will contain a detailed documentation in future.
+
+
+
+
+
+
+[1] Andraka, Ray; A survey of CORDIC algorithms for FPGA based computers, 1989
+[2] Hu, Yu Hen; CORDIC-Based VLSI Architectures for Digital Signal Processing, 1992
+[3] CORDIC on wikibook: http://en.wikibooks.org/wiki/Digital_Circuits/CORDIC
+[4] CORDIC on wikipedia:http://en.wikipedia.org/wiki/CORDIC
+[5] David, Herbert; Meyr, Heinricht; CORDIC Algorithms and Architectures
+ http://www.eecs.berkeley.edu/newton/Classes/EE290sp99/lectures/ee290aSp996_1/cordic_chap24.pdf
+
+