OpenCores
URL https://opencores.org/ocsvn/yac/yac/trunk

Subversion Repositories yac

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /yac/trunk
    from Rev 2 to Rev 3
    ↔ Reverse comparison
  •

Rev 2 → Rev 3

/rtl/vhdl/cordic_iterative_pkg.vhd
61,8 → 61,13
 
<<<<<<< HEAD
constant I_FLAG_VEC_ROT : natural := 3; -- bit index
constant I_FLAG_ATAN_3 : natural := 2; -- bit index (for future usage)
=======
constant FLAG_VEC_ROT : natural := 3; -- bit index
constant FLAG_ATAN_3 : natural := 2; -- bit index
>>>>>>> initial commit
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
/rtl/vhdl/cordic_iterative_tb.vhd
251,6 → 251,7
y_ex /= y_o or
a_ex /= a_o then
assert x_ex = x_o report
<<<<<<< HEAD
integer'image( stim_cnt ) & ": Serial Cordic Failed: expected x result:"
& integer'image( tmp_value(5) ) & ", but got:"
& integer'image( to_integer( signed( x_ex ) ) );
260,6 → 261,17
& integer'image( to_integer( signed( y_ex ) ) );
assert a_ex = a_o report
integer'image( stim_cnt ) & ": Serial Cordic Failed: expected a result:"
=======
" 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
" 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
" Serial Cordic Failed: expected a result:"
>>>>>>> initial commit
& integer'image( tmp_value(7) ) & ", but got:"
& integer'image( to_integer( signed( a_ex ) ) );
err_cnt := err_cnt + 1;
/rtl/vhdl/cordic_iterative_int.vhd
92,6 → 92,7
 
-- Internal angle width
constant A_WIDTH_I : natural := A_WIDTH+2;
<<<<<<< HEAD
 
constant SQRT2_REAL : real := 1.4142135623730951454746218587388284504413604;
101,6 → 102,12
constant SQRT2 : integer := natural( SQRT2_REAL * real( 2**( XY_WIDTH-1 ) ) + 0.5 );
constant XY_MAX : integer := natural( 2**( XY_WIDTH-1)-1);
 
=======
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 );
>>>>>>> initial commit
 
constant XY_WIDTH_G : natural := XY_WIDTH + GUARD_BITS;
 
224,6 → 231,7
state.a <= resize( signed( a_i ), state.a'length );
state.i <= ( others => '0' );
<<<<<<< HEAD
elsif state.st = ST_INIT then
--
-- initialization state
231,12 → 239,25
-- -> check special situations / miss-configurations (TODO)
--
 
=======
--
-- initialization state
-- -> do initial rotation (alignment)
-- -> check special situations / miss-configurations (TODO)
--
elsif state.st = ST_INIT then
>>>>>>> initial commit
state.st <= ST_ROTATE;
state.do_shift <= '1';
 
 
<<<<<<< HEAD
if state.mode( 1 downto 0 ) = VAL_MODE_HYP then
-- if we do a hyperbolic rotation, we start with 1
=======
-- if we do a hyperbolic rotation, we start with 1
if state.mode( 1 downto 0 ) = VAL_MODE_HYP then
>>>>>>> initial commit
state.i(0) <= '1';
end if;
 
243,6 → 264,7
 
 
 
<<<<<<< HEAD
if state.mode( I_FLAG_VEC_ROT ) = '0'
and state.mode( 1 downto 0 ) = VAL_MODE_CIR then
-- circular vector mode
254,11 → 276,25
state.y <= - state.y;
elsif state.a > PI_H then
-- move from second quadrant to fourth
=======
-- circular vector mode
if state.mode( FLAG_VEC_ROT ) = '0'
and state.mode( 1 downto 0 ) = VAL_MODE_CIR then
 
-- move from third quadrant to first
if state.a < - PI_H then
state.a <= state.a + PI;
state.x <= - state.x;
state.y <= - state.y;
-- move from second quadrant to fourth
elsif state.a > PI_H then
>>>>>>> initial commit
state.a <= state.a - PI;
state.x <= - state.x;
state.y <= - state.y;
end if;
 
<<<<<<< HEAD
elsif state.mode( I_FLAG_VEC_ROT ) = '1'
and state.mode( 1 downto 0 ) = VAL_MODE_CIR then
-- circular rotation mode
328,7 → 364,39
state.y <= - state.y;
end if;
state.a <= to_signed( 0, state.a'length );
=======
-- circular rotation mode
elsif state.mode( FLAG_VEC_ROT ) = '1'
and state.mode( 1 downto 0 ) = VAL_MODE_CIR then
 
-- move from second quadrant to fourth
if state.x < 0 and state.y > 0 then
state.x <= - state.x;
state.y <= - state.y;
state.a <= to_signed( PI, state.a'length );
-- move from third quadrant to first
elsif state.x < 0 and state.y < 0 then
state.x <= - state.x;
state.y <= - state.y;
state.a <= to_signed( -PI, state.a'length );
-- y=0 condition
elsif state.x < 0 and state.y = 0 then
state.a <= to_signed( PI, state.a'length );
state.st<= ST_DONE;
else
state.a <= ( others => '0' );
end if;
-- linear rotation mode
elsif state.mode( FLAG_VEC_ROT ) = '1'
and state.mode( 1 downto 0 ) = VAL_MODE_LIN then
 
if state.x < 0 then
state.x <= - state.x;
state.y <= - state.y;
end if;
state.a <= to_signed( 0, state.a'length );
>>>>>>> initial commit
 
end if;
 
 
348,7 → 416,11
elsif state.st = ST_ROTATE then
 
-- get the sign
<<<<<<< HEAD
if state.mode( I_FLAG_VEC_ROT ) = '0' then
=======
if state.mode( FLAG_VEC_ROT ) = '0' then
>>>>>>> initial commit
if state.a < 0 then
sign := '0';
else
417,6 → 489,7
state.do_shift <= '0';
 
-- abort condition
<<<<<<< HEAD
if( state.mode( I_FLAG_VEC_ROT ) = '0' and
state.a = 0 ) then
state.st <= ST_RM_GAIN;
430,6 → 503,21
state.st <= ST_RM_GAIN;
state.i <= ( others => '0' );
elsif( state.mode( I_FLAG_VEC_ROT ) = '1' and
=======
if( state.mode( FLAG_VEC_ROT ) = '0' and
( state.a = 0 or state.a = -1 ) ) then
state.st <= ST_RM_GAIN;
state.i <= ( others => '0' );
elsif( state.mode( FLAG_VEC_ROT ) = '0' and
( state.a = state.alst ) ) then
state.st <= ST_RM_GAIN;
state.i <= ( others => '0' );
elsif( state.mode( FLAG_VEC_ROT ) = '1' and
( state.y = 0 or state.y = -1 ) ) then
state.st <= ST_RM_GAIN;
state.i <= ( others => '0' );
elsif( state.mode( FLAG_VEC_ROT ) = '1' and
>>>>>>> initial commit
( state.y = state.ylst ) ) then
state.st <= ST_RM_GAIN;
state.i <= ( others => '0' );
/c_octave/cordic_iterative.c
59,7 → 59,11
#include "mex.h"
 
/* enable debug output */
<<<<<<< HEAD
#define PRINT_DEBUG 0
=======
#define PRINT_DEBUG 0
>>>>>>> initial commit
 
 
/* #define CORDIC_ROUNDING 0.5 */
80,6 → 84,24
 
 
 
<<<<<<< HEAD
=======
 
long long int ov_check( long long int * value, long long int length )
{
long long int mask = (1<<length)-1;
long long int result = 0;
long long int min = -((long long int)1<<length);
long long int max = ((long long int)1<<length);
if( *value > max || *value < min )
result = *value;
/* *value &= mask; */
return result;
}
 
 
 
>>>>>>> initial commit
void cordic_int( long long int x_i,
long long int y_i,
long long int a_i,
102,8 → 124,12
long long int *y,
long long int *a,
int mode,
<<<<<<< HEAD
int A_WIDTH,
int XY_WIDTH );
=======
int A_WIDTH );
>>>>>>> initial commit
void cordic_int_rm_gain( long long int *x,
long long int *y,
int mode,
232,7 → 258,11
long long int a;
long long int s;
int ov;
<<<<<<< HEAD
int it = 0;
=======
int it;
>>>>>>> initial commit
 
 
242,6 → 272,7
cordic_int_dbg( x_i, y_i, a_i, mode, 0, "input" );
 
<<<<<<< HEAD
if( !cordic_int_init( &x_i, &y_i, &a_i, mode, A_WIDTH, XY_WIDTH ) )
{
 
249,7 → 280,15
 
cordic_int_rm_gain( &x_i, &y_i, mode, RM_GAIN );
}
=======
cordic_int_init( &x_i, &y_i, &a_i, mode, A_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 );
 
>>>>>>> initial commit
 
*x_o = x_i;
*y_o = y_i;
*a_o = a_i;
267,8 → 306,12
long long int *y,
long long int *a,
int mode,
<<<<<<< HEAD
int A_WIDTH,
int XY_WIDTH )
=======
int A_WIDTH )
>>>>>>> initial commit
{
int already_done = 0;
 
275,6 → 318,7
 
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 );
<<<<<<< HEAD
long long int XY_MAX = pow( 2, XY_WIDTH-1 )-1;
281,6 → 325,11
cordic_int_dbg( *x, *y, *a, mode, 0, "before init" );
 
 
=======
cordic_int_dbg( *x, *y, *a, mode, 0, "before init" );
>>>>>>> initial commit
/* Circular rotation mode */
if( 0 == ( mode & C_FLAG_VEC_ROT ) &&
C_MODE_CIR == ( mode & C_MODE_MSK ) )
315,6 → 364,7
else if ( 0 != ( mode & C_FLAG_VEC_ROT ) &&
C_MODE_CIR == ( mode & C_MODE_MSK ) )
{
<<<<<<< HEAD
 
if( *x == 0 && *y == 0 )
{
384,23 → 434,44
#endif
}
else if( *x < 0 && *y >= 0 )
=======
if( *x < 0 && *y > 0 )
>>>>>>> initial commit
{
*x = -*x;
*y = -*y;
*a = PI;
#if PRINT_DEBUG > 0
<<<<<<< HEAD
PRINT("pre-rotation from second to the fourth quadrant\n" );
#endif
}
else if( *x < 0 && *y < 0 )
=======
PRINT("align from second quadrand\n" );
#endif
}
else if( *x < 0 && *y < 0 )
>>>>>>> initial commit
{
*x = -*x;
*y = -*y;
*a = -PI;
#if PRINT_DEBUG > 0
<<<<<<< HEAD
PRINT("pre-rotation from third to first quadrand\n" );
#endif
}
=======
PRINT("align from third quadrand\n" );
#endif
}
else if( *x < 0 && *y == 0 )
{
*a = PI;
already_done = 1;
}
>>>>>>> initial commit
else
*a = 0;
}
417,7 → 488,11
}
 
cordic_int_dbg( *x, *y, *a, mode, 0, "after init" );
<<<<<<< HEAD
return already_done;
=======
>>>>>>> initial commit
}
 
 
534,7 → 609,11
/* abort condition */
if( ( mode & C_FLAG_VEC_ROT ) == 0 &&
<<<<<<< HEAD
( *a == 0 /* || *a == -1 */ ) )
=======
( *a == 0 || *a == -1 ) )
>>>>>>> initial commit
break;
if( ( mode & C_FLAG_VEC_ROT ) == 0 &&
( *a == alst ) )
541,7 → 620,11
break;
if( ( mode & C_FLAG_VEC_ROT ) != 0 &&
<<<<<<< HEAD
( *y == 0 /*|| *y == -1 */ ) )
=======
( *y == 0 || *y == -1 ) )
>>>>>>> initial commit
break;
if( ( mode & C_FLAG_VEC_ROT ) != 0 &&
( *y == ylst ) )
/c_octave/cordic_iterative_code.m
68,8 → 68,11
% TODO: calculate these values
K0 = 0.607252935009;
K1 = 0.207497067763;
<<<<<<< HEAD
%prod( sqrt( 1-2.^(-2 .* [ 1 : 100000 ] ) ) )
 
=======
>>>>>>> initial commit
 
signs = get_rm_gain_shifts( K0, 30 );
print_rm_gain_code( fid, signs, K0, 1, 1, 0 );
84,7 → 87,11
print_rm_gain_code( fid, signs, K1, 1, 0, 1 );
 
MAX_A_WIDTH = 32;
<<<<<<< HEAD
print_angular_lut( fid, MAX_A_WIDTH );
=======
print_angular_lut( fid, MAX_A_WIDTH )
>>>>>>> initial commit
 
 
fclose( fid );
195,7 → 202,11
end
for y = 1 : length( tmp2 )
<<<<<<< HEAD
fprintf( fid, '%c ( x >> %d ) ', tmp2{ y }, index( y ) );
=======
fprintf( fid, '%c ( x >> %d ) ', tmp2{ y }, index( y ) )
>>>>>>> initial commit
end
fprintf( fid, '; break; /* error: %.10f */ \n', err );
else
/c_octave/cordic_iterative_test.m
20,6 → 20,7
%%%% implementation behaves the same than the VHDL %%%%
%%%% implementation. %%%%
%%%% %%%%
<<<<<<< HEAD
%%%% Three tests are implemented: %%%%
%%%% - Random test values %%%%
%%%% - Linear increasing values %%%%
28,11 → 29,17
%%%% %%%%
%%%% Please do 'mex cordic_iterative.c' to create %%%%
%%%% the cordic_iterative.mex. %%%%
=======
>>>>>>> initial commit
%%%% %%%%
%%%%% %%%%%
%%%% %%%%
%%%% TODO %%%%
<<<<<<< HEAD
%%%% The linear test is not complete %%%%
=======
%%%% Some documentation and function description %%%%
>>>>>>> initial commit
%%%% %%%%
%%%% %%%%
%%%% %%%%
59,10 → 66,27
%%%% http://www.gnu.org/licenses/lgpl %%%%
%%%% %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
<<<<<<< HEAD
function cordic_iterative_test( )
 
 
 
=======
 
 
 
function cordic_iterative_test( )
%
%
% Please do 'mex cordic_iterative.c' to create
% the cordic_iterative.mex
%
%
%
%
 
 
>>>>>>> initial commit
% 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
95,6 → 119,7
 
% open test file
tb_fid = fopen( './tb_data.txt', 'w' );
<<<<<<< HEAD
%tb_fid = 0;
 
 
171,11 → 196,21
0, 0, ...
0, 0, ...
'Limit Value Test' );
=======
 
% run test, which uses random values
run_random_test( N_TESTS, tb_fid );
 
% close file
fclose( tb_fid );
 
>>>>>>> initial commit
 
end
 
 
 
<<<<<<< HEAD
function run_linear_test( N_TESTS, tb_fid )
%RUN_LINEAR_TEST Generates a linear test pattern
%
231,6 → 266,13
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 );
=======
function run_random_test( N_TESTS, tb_fid )
 
data_a = -1 + 2 .* rand( 1, N_TESTS );
data_b = -1 + 2 .* rand( 1, N_TESTS );
 
>>>>>>> initial commit
% adapat data for division
data_a_div = data_a;
data_b_div = data_b;
239,11 → 281,16
data_b_div( swap_div ) = data_a( swap_div );
 
data_a_h = ones( size( data_a ) );
<<<<<<< HEAD
data_b_h = data_b .* 0.80694; %0.78;
=======
data_b_h = data_b .* 0.78;
>>>>>>> initial commit
 
 
 
[ ~, ~, atan_err, abs_err, it_1 ] = ccart2pol( data_a, data_b, tb_fid );
<<<<<<< HEAD
[ ~, ~, 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 );
303,10 → 350,34
 
end
 
=======
[ ~, ~, sin_err, cos_err, it_2 ] = cpol2cart( data_a, data_b, tb_fid );
[ ~, div_err, it_3 ] = cdiv( data_a_div, data_b_div, tb_fid );
[ ~, mul_err, it_4 ] = cmul( data_a, data_b, tb_fid );
[ ~, ~, atanh_err, sqrt_err, it_5 ] = catanh( data_a_h, data_b_h, tb_fid );
[ ~, ~, sinh_err, cosh_err, it_6 ] = csinhcosh( data_a, tb_fid );
 
fprintf( ' ___________________________________________________________________\n' );
fprintf( ' Random Value Test \n' );
fprintf( ' -----+-------------------+--------------------+-------------------\n' );
fprintf( ' | max error | mean error | max iterations \n' );
fprintf( ' atan | % .14f | % .14f | %.5f \n', max( atan_err ), mean( atan_err ), max( it_1 ) );
fprintf( ' abs | % .14f | % .14f | %.5f \n', max( abs_err ), mean( abs_err ), max( it_1 ) );
fprintf( ' sin | % .14f | % .14f | %.5f \n', max( sin_err ), mean( sin_err ), max( it_2 ) );
fprintf( ' cos | % .14f | % .14f | %.5f \n', max( cos_err ), mean( cos_err ), max( it_2 ) );
fprintf( ' div | % .14f | % .14f | %.5f \n', max( div_err ), mean( div_err ), max( it_3 ) );
fprintf( ' mul | % .14f | % .14f | %.5f \n', max( mul_err ), mean( mul_err ), mean( it_4 ) );
fprintf( ' atanh| % .14f | % .14f | %.5f \n', max( atanh_err), mean( atanh_err ), mean( it_5 ) );
fprintf( ' sinh | % .14f | % .14f | %.5f \n', max( sinh_err ), mean( sinh_err ), mean( it_6 ) );
fprintf( ' cosh | % .14f | % .14f | %.5f \n', max( cosh_err ), mean( cosh_err ), mean( it_6 ) );
 
 
end
>>>>>>> initial commit
 
 
 
 
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
467,6 → 538,7
end
 
 
<<<<<<< HEAD
function [x_res, y_res, x_err, y_err, it ] = crot( x, y, th, fid )
%
% does a multiplication with exp( th * i )
512,6 → 584,12
% does the Matlab equivalent pol2cart
%
 
=======
 
 
 
function [sin_res, cos_res, sin_err, cos_err, it ]= cpol2cart( th, r, fid )
>>>>>>> initial commit
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
 
519,8 → 597,17
yi = zeros( 1, length( th ) );
ai = round( th .* (2^(ANGLEWIDTH-1)-1) );
 
<<<<<<< HEAD
mode = C_MODE_CIRC;
 
=======
 
 
mode = C_MODE_CIRC;
 
 
% cordic version
>>>>>>> initial commit
[ rcos rsin ra, it ] = cordic_iterative( ...
xi, ...
yi, ...
548,7 → 635,10
 
 
 
<<<<<<< HEAD
 
=======
>>>>>>> initial commit
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
574,10 → 664,15
ANGLEWIDTH, ...
GUARDBITS, ...
RM_GAIN );
<<<<<<< HEAD
% matlab version:
m_th = atan2( y, x );
m_r = sqrt( x.^2 + y.^2 );
 
=======
% matlab version
[m_th, m_r ] = cart2pol( x, y );
>>>>>>> initial commit
 
% comparison
atan_res = ra ./ 2^( (ANGLEWIDTH)-1);
585,8 → 680,11
atan_err = abs( m_th - atan_res );
abs_err = abs( m_r - abs_res );
 
<<<<<<< HEAD
% TODO: ATAN oder ATAN2 atan( 0 / x ) != atan2( 0, x )!!!!
 
=======
>>>>>>> initial commit
% write TB data
write_tb( fid, xi, yi, ai, rx, ry, ra, mode )
 
/lgpl-3.0.txt
0,0 → 1,165
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
 
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
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.
/README.txt
23,6 → 23,7
 
 
 
<<<<<<< HEAD
Author(s): Christian Haettich
Email feddischson@opencores.org
 
90,6 → 91,8
 
 
 
=======
>>>>>>> initial commit
 
Files and folders:
------------------
108,6 → 111,7
 
 
 
<<<<<<< HEAD
 
 
[1] Andraka, Ray; A survey of CORDIC algorithms for FPGA based computers, 1989
118,3 → 122,5
http://www.eecs.berkeley.edu/newton/Classes/EE290sp99/lectures/ee290aSp996_1/cordic_chap24.pdf
 
 
=======
>>>>>>> initial commit

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.