URL
https://opencores.org/ocsvn/yac/yac/trunk
Subversion Repositories yac
Compare Revisions
- This comparison shows the changes necessary to convert path
/yac/trunk/c_octave
- from Rev 11 to Rev 13
- ↔ Reverse comparison
Rev 11 → Rev 13
/cordic_iterative.c
62,15 → 62,7
#endif |
|
/* enable debug output */ |
<<<<<<< HEAD |
<<<<<<< HEAD |
#define PRINT_DEBUG 0 |
======= |
#define PRINT_DEBUG 0 |
>>>>>>> initial commit |
======= |
#define PRINT_DEBUG 0 |
>>>>>>> Updated C and RTL model as well as the documentation |
|
/* #define CORDIC_ROUNDING 0.5 */ |
#define CORDIC_ROUNDING 0.0 |
90,27 → 82,6
#endif |
|
|
<<<<<<< HEAD |
<<<<<<< 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 |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
void cordic_int( long long int x_i, |
long long int y_i, |
long long int a_i, |
133,17 → 104,8
long long int *y, |
long long int *a, |
int mode, |
<<<<<<< HEAD |
<<<<<<< HEAD |
int A_WIDTH, |
int XY_WIDTH ); |
======= |
int A_WIDTH ); |
>>>>>>> initial commit |
======= |
int A_WIDTH, |
int XY_WIDTH ); |
>>>>>>> Updated C and RTL model as well as the documentation |
void cordic_int_rm_gain( long long int *x, |
long long int *y, |
int mode, |
272,15 → 234,7
long long int a; |
long long int s; |
int ov; |
<<<<<<< HEAD |
<<<<<<< HEAD |
int it = 0; |
======= |
int it; |
>>>>>>> initial commit |
======= |
int it = 0; |
>>>>>>> Updated C and RTL model as well as the documentation |
|
|
|
290,8 → 244,6
|
cordic_int_dbg( x_i, y_i, a_i, mode, 0, "input" ); |
|
<<<<<<< HEAD |
<<<<<<< HEAD |
if( !cordic_int_init( &x_i, &y_i, &a_i, mode, A_WIDTH, XY_WIDTH ) ) |
{ |
|
299,24 → 251,7
|
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 ); |
======= |
if( !cordic_int_init( &x_i, &y_i, &a_i, mode, A_WIDTH, XY_WIDTH ) ) |
{ |
>>>>>>> Updated C and RTL model as well as the documentation |
|
it = cordic_int_rotate( &x_i, &y_i, &a_i, mode, A_WIDTH ); |
|
<<<<<<< HEAD |
>>>>>>> initial commit |
======= |
cordic_int_rm_gain( &x_i, &y_i, mode, RM_GAIN ); |
} |
>>>>>>> Updated C and RTL model as well as the documentation |
|
*x_o = x_i; |
*y_o = y_i; |
*a_o = a_i; |
334,17 → 269,8
long long int *y, |
long long int *a, |
int mode, |
<<<<<<< HEAD |
<<<<<<< HEAD |
int A_WIDTH, |
int XY_WIDTH ) |
======= |
int A_WIDTH ) |
>>>>>>> initial commit |
======= |
int A_WIDTH, |
int XY_WIDTH ) |
>>>>>>> Updated C and RTL model as well as the documentation |
{ |
int already_done = 0; |
|
351,33 → 277,12
|
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 |
<<<<<<< HEAD |
<<<<<<< HEAD |
|
long long int XY_MAX = pow( 2, XY_WIDTH-1 )-1; |
|
cordic_int_dbg( *x, *y, *a, mode, 0, "before init" ); |
|
|
======= |
|
|
cordic_int_dbg( *x, *y, *a, mode, 0, "before init" ); |
>>>>>>> initial commit |
======= |
|
======= |
|
>>>>>>> Removed some bugs regarding pre-rotation and negative numbers in the wb wrapper |
long long int XY_MAX = pow( 2, XY_WIDTH-1 )-1; |
|
cordic_int_dbg( *x, *y, *a, mode, 0, "before init" ); |
|
|
<<<<<<< HEAD |
>>>>>>> Updated C and RTL model as well as the documentation |
======= |
if( 0 != ( mode & C_FLAG_VEC_ROT ) && *y == 0 ) |
{ |
already_done = 1; |
394,7 → 299,6
already_done = 1; |
} |
|
>>>>>>> Removed some bugs regarding pre-rotation and negative numbers in the wb wrapper |
/* Circular rotation mode */ |
else if( 0 == ( mode & C_FLAG_VEC_ROT ) && |
C_MODE_CIR == ( mode & C_MODE_MSK ) ) |
431,10 → 335,6
else if ( 0 != ( mode & C_FLAG_VEC_ROT ) && |
C_MODE_CIR == ( mode & C_MODE_MSK ) ) |
{ |
<<<<<<< HEAD |
<<<<<<< HEAD |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
|
if( *x == XY_MAX && *y == XY_MAX ) |
{ |
500,60 → 400,23
#endif |
} |
else if( *x < 0 && *y >= 0 ) |
<<<<<<< HEAD |
======= |
if( *x < 0 && *y > 0 ) |
>>>>>>> initial commit |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
{ |
*x = -*x; |
*y = -*y; |
*a = PI; |
#if PRINT_DEBUG > 0 |
<<<<<<< HEAD |
<<<<<<< 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 |
======= |
PRINT("pre-rotation from second to the fourth quadrant\n" ); |
#endif |
} |
else if( *x < 0 && *y < 0 ) |
>>>>>>> Updated C and RTL model as well as the documentation |
{ |
*x = -*x; |
*y = -*y; |
*a = -PI; |
#if PRINT_DEBUG > 0 |
<<<<<<< HEAD |
<<<<<<< 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 |
======= |
PRINT("pre-rotation from third to first quadrand\n" ); |
#endif |
} |
>>>>>>> Updated C and RTL model as well as the documentation |
else |
*a = 0; |
} |
569,15 → 432,7
*a = 0; |
} |
cordic_int_dbg( *x, *y, *a, mode, 0, "after init" ); |
<<<<<<< HEAD |
<<<<<<< HEAD |
return already_done; |
======= |
|
>>>>>>> initial commit |
======= |
return already_done; |
>>>>>>> Updated C and RTL model as well as the documentation |
} |
|
|
694,15 → 549,7
|
/* abort condition */ |
if( ( mode & C_FLAG_VEC_ROT ) == 0 && |
<<<<<<< HEAD |
<<<<<<< HEAD |
( *a == 0 /* || *a == -1 */ ) ) |
======= |
( *a == 0 || *a == -1 ) ) |
>>>>>>> initial commit |
======= |
( *a == 0 /* || *a == -1 */ ) ) |
>>>>>>> Updated C and RTL model as well as the documentation |
break; |
if( ( mode & C_FLAG_VEC_ROT ) == 0 && |
( *a == alst ) ) |
709,15 → 556,7
break; |
|
if( ( mode & C_FLAG_VEC_ROT ) != 0 && |
<<<<<<< HEAD |
<<<<<<< HEAD |
( *y == 0 /*|| *y == -1 */ ) ) |
======= |
( *y == 0 || *y == -1 ) ) |
>>>>>>> initial commit |
======= |
( *y == 0 /*|| *y == -1 */ ) ) |
>>>>>>> Updated C and RTL model as well as the documentation |
break; |
if( ( mode & C_FLAG_VEC_ROT ) != 0 && |
( *y == ylst ) ) |
/cordic_iterative_code.m
68,17 → 68,9
% TODO: calculate these values |
K0 = 0.607252935009; |
K1 = 0.207497067763; |
<<<<<<< HEAD |
<<<<<<< HEAD |
%prod( sqrt( 1-2.^(-2 .* [ 1 : 100000 ] ) ) ) |
|
======= |
>>>>>>> initial commit |
======= |
%prod( sqrt( 1-2.^(-2 .* [ 1 : 100000 ] ) ) ) |
|
>>>>>>> Updated C and RTL model as well as the documentation |
|
signs = get_rm_gain_shifts( K0, 30 ); |
print_rm_gain_code( fid, signs, K0, 1, 1, 0 ); |
|
92,15 → 84,7
print_rm_gain_code( fid, signs, K1, 1, 0, 1 ); |
|
MAX_A_WIDTH = 32; |
<<<<<<< HEAD |
<<<<<<< HEAD |
print_angular_lut( fid, MAX_A_WIDTH ); |
======= |
print_angular_lut( fid, MAX_A_WIDTH ) |
>>>>>>> initial commit |
======= |
print_angular_lut( fid, MAX_A_WIDTH ); |
>>>>>>> Updated C and RTL model as well as the documentation |
|
|
fclose( fid ); |
211,15 → 195,7
end |
|
for y = 1 : length( tmp2 ) |
<<<<<<< HEAD |
<<<<<<< HEAD |
fprintf( fid, '%c ( x >> %d ) ', tmp2{ y }, index( y ) ); |
======= |
fprintf( fid, '%c ( x >> %d ) ', tmp2{ y }, index( y ) ) |
>>>>>>> initial commit |
======= |
fprintf( fid, '%c ( x >> %d ) ', tmp2{ y }, index( y ) ); |
>>>>>>> Updated C and RTL model as well as the documentation |
end |
fprintf( fid, '; break; /* error: %.10f */ \n', err ); |
else |
/cordic_iterative_test.m
20,10 → 20,6
%%%% implementation behaves the same than the VHDL %%%% |
%%%% implementation. %%%% |
%%%% %%%% |
<<<<<<< HEAD |
<<<<<<< HEAD |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
%%%% Three tests are implemented: %%%% |
%%%% - Random test values %%%% |
%%%% - Linear increasing values %%%% |
32,24 → 28,11
%%%% %%%% |
%%%% Please do 'mex cordic_iterative.c' to create %%%% |
%%%% the cordic_iterative.mex. %%%% |
<<<<<<< HEAD |
======= |
>>>>>>> initial commit |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
%%%% %%%% |
%%%%% %%%%% |
%%%% %%%% |
%%%% TODO %%%% |
<<<<<<< HEAD |
<<<<<<< HEAD |
%%%% The linear test is not complete %%%% |
======= |
%%%% Some documentation and function description %%%% |
>>>>>>> initial commit |
======= |
%%%% The linear test is not complete %%%% |
>>>>>>> Updated C and RTL model as well as the documentation |
%%%% %%%% |
%%%% %%%% |
%%%% %%%% |
76,23 → 59,10
%%%% http://www.gnu.org/licenses/lgpl %%%% |
%%%% %%%% |
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
<<<<<<< HEAD |
<<<<<<< HEAD |
function cordic_iterative_test( ) |
|
|
|
======= |
|
|
|
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
function cordic_iterative_test( ) |
|
|
|
>>>>>>> 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 |
107,17 → 77,7
% Number of tests, which are run |
N_TESTS = 10000; |
|
<<<<<<< HEAD |
% open test file |
tb_fid = fopen( './tb_data.txt', 'w' ); |
<<<<<<< HEAD |
<<<<<<< HEAD |
%tb_fid = 0; |
|
|
|
|
|
% |
% run test, which uses random values |
run_random_test( N_TESTS, tb_fid ); |
162,123 → 122,7
-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' ); |
======= |
======= |
%tb_fid = 0; |
|
>>>>>>> Updated C and RTL model as well as the documentation |
|
|
|
======= |
>>>>>>> Removed some bugs regarding pre-rotation and negative numbers in the wb wrapper |
|
% |
% 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. |
% |
|
|
<<<<<<< HEAD |
>>>>>>> initial commit |
|
end |
|
|
|
<<<<<<< HEAD |
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 ); |
|
======= |
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 ]; |
|
304,28 → 148,11
0, 0, ... |
0, 0, ... |
'Limit Value Test' ); |
>>>>>>> Updated C and RTL model as well as the documentation |
|
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 |
|
|
|
<<<<<<< HEAD |
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. |
======= |
function run_linear_test( N_TESTS, tb_fid ) |
%RUN_LINEAR_TEST Generates a linear test pattern |
% |
339,7 → 166,6
% |
% NOTE: only the hyperbolic functions are processed at the moment. |
% This function needs to be extended in future. |
>>>>>>> Updated C and RTL model as well as the documentation |
% |
% |
% The argument fid is the file-descriptor of the testbench pattern |
346,14 → 172,6
% file. The argument N defines the number of values, which are processed. |
% |
% |
<<<<<<< HEAD |
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 ); |
======= |
function run_random_test( N_TESTS, tb_fid ) |
======= |
|
data_a_h = ones( 1, N_TESTS ); |
data_b_h = linspace( -1, 1, N_TESTS ) * 0.78; |
371,7 → 189,6
end |
|
|
>>>>>>> Updated C and RTL model as well as the documentation |
|
function run_random_test( N_TESTS, tb_fid ) |
%RUN_RANDOM_TEST Generates a random test pattern |
391,13 → 208,8
% |
data_a = -1 + 2 .* rand( 1, N_TESTS ); |
data_b = -1 + 2 .* rand( 1, N_TESTS ); |
<<<<<<< HEAD |
|
>>>>>>> initial commit |
======= |
data_c = -1 + 2 .* rand( 1, N_TESTS ); |
data_d = -pi + 2*pi .* rand( 1, N_TESTS ); |
>>>>>>> Updated C and RTL model as well as the documentation |
% adapat data for division |
data_a_div = data_a; |
data_b_div = data_b; |
406,23 → 218,11
data_b_div( swap_div ) = data_a( swap_div ); |
|
data_a_h = ones( size( data_a ) ); |
<<<<<<< HEAD |
<<<<<<< HEAD |
data_b_h = data_b .* 0.80694; %0.78; |
======= |
data_b_h = data_b .* 0.78; |
>>>>>>> initial commit |
======= |
data_b_h = data_b .* 0.80694; %0.78; |
>>>>>>> Updated C and RTL model as well as the documentation |
|
|
|
[ ~, ~, atan_err, abs_err, it_1 ] = ccart2pol( data_a, data_b, tb_fid ); |
<<<<<<< HEAD |
<<<<<<< HEAD |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
[ ~, ~, 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 ); |
484,7 → 284,6
sinh_err, sinh_it, ... |
cosh_err, cosh_it, ... |
title ) |
<<<<<<< HEAD |
|
fprintf( ' ___________________________________________________________________\n' ); |
fprintf( ' %s\n', title); |
504,40 → 303,11
fprintf( ' cosh | % .14f | % .14f | %.5f \n', max( cosh_err ), mean( cosh_err ), max( cosh_it ) ); |
|
|
======= |
[ ~, ~, 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 ); |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
|
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 |
>>>>>>> initial commit |
|
|
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 |
698,10 → 468,6
end |
|
|
<<<<<<< HEAD |
<<<<<<< HEAD |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
function [x_res, y_res, x_err, y_err, it ] = crot( x, y, th, fid ) |
% |
% does a multiplication with exp( th * i ) |
747,15 → 513,6
% does the Matlab equivalent pol2cart |
% |
|
<<<<<<< HEAD |
======= |
|
|
|
function [sin_res, cos_res, sin_err, cos_err, it ]= cpol2cart( th, r, fid ) |
>>>>>>> initial commit |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
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 |
|
763,22 → 520,8
yi = zeros( 1, length( th ) ); |
ai = round( th .* (2^(ANGLEWIDTH-1)-1) ); |
|
<<<<<<< HEAD |
<<<<<<< HEAD |
mode = C_MODE_CIRC; |
|
======= |
|
|
mode = C_MODE_CIRC; |
|
|
% cordic version |
>>>>>>> initial commit |
======= |
mode = C_MODE_CIRC; |
|
>>>>>>> Updated C and RTL model as well as the documentation |
[ rcos rsin ra, it ] = cordic_iterative( ... |
xi, ... |
yi, ... |
806,14 → 549,7
|
|
|
<<<<<<< HEAD |
<<<<<<< HEAD |
|
======= |
>>>>>>> initial commit |
======= |
|
>>>>>>> Updated C and RTL model as well as the documentation |
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 |
838,21 → 574,10
ANGLEWIDTH, ... |
GUARDBITS, ... |
RM_GAIN ); |
<<<<<<< HEAD |
<<<<<<< HEAD |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
% matlab version: |
m_th = atan2( y, x ); |
m_r = sqrt( x.^2 + y.^2 ); |
|
<<<<<<< HEAD |
======= |
% matlab version |
[m_th, m_r ] = cart2pol( x, y ); |
>>>>>>> initial commit |
======= |
>>>>>>> Updated C and RTL model as well as the documentation |
|
% comparison |
atan_res = ra ./ 2^( (ANGLEWIDTH)-1); |
860,16 → 585,8
atan_err = abs( m_th - atan_res ); |
abs_err = abs( m_r - abs_res ); |
|
<<<<<<< HEAD |
<<<<<<< HEAD |
% TODO: ATAN oder ATAN2 atan( 0 / x ) != atan2( 0, x )!!!! |
|
======= |
>>>>>>> initial commit |
======= |
% TODO: ATAN oder ATAN2 atan( 0 / x ) != atan2( 0, x )!!!! |
|
>>>>>>> Updated C and RTL model as well as the documentation |
% write TB data |
write_tb( fid, xi, yi, ai, rx, ry, ra, mode ) |
|