开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 3G开发 > 查看源码
CORDIC.bsv
资源名称：mit-ofdm-wifi.rar　[点击查看]
上传用户：aoptech
上传日期：2014-09-22
资源大小：784k
文件大小：19k
源码类别：

3G开发

开发平台：

Others

CORDIC.bsv：源码内容
  1. //----------------------------------------------------------------------//
  2. // The MIT License 
  3. // 
  4. // Copyright (c) 2007 Alfred Man Cheuk Ng, mcn02@mit.edu 
  5. // 
  6. // Permission is hereby granted, free of charge, to any person 
  7. // obtaining a copy of this software and associated documentation 
  8. // files (the "Software"), to deal in the Software without 
  9. // restriction, including without limitation the rights to use,
  10. // copy, modify, merge, publish, distribute, sublicense, and/or sell
  11. // copies of the Software, and to permit persons to whom the
  12. // Software is furnished to do so, subject to the following conditions:
  13. // 
  14. // The above copyright notice and this permission notice shall be
  15. // included in all copies or substantial portions of the Software.
  16. // 
  17. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  19. // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  21. // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22. // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24. // OTHER DEALINGS IN THE SOFTWARE.
  25. //----------------------------------------------------------------------//
  27. ///////////////////////////////////////////////////////////////////////////////////////////
  28. //
  29. // File: CORDIC.bsv
  30. // Description: Provides cos, sin and arctan using CORDIC
  31. // Author: Man C Ng, Email: mcn02@mit.edu
  32. // Date: 26, June, 2006
  33. // Last Modified: 10, Oct, 2006
  34. //
  35. //////////////////////////////////////////////////////////////////////////////////////////
  37. import FIFO::*;
  38. import FixedPoint::*;
  39. import Pipelines::*;
  40. import Vector::*;
  42. /////////////////////////////////////////////////////////////////////////////////////////
  43. // Begin of Data Types
  45. // a pair of values representing the result of cos and sin to the same angle
  46. typedef struct
  47. {
  48.   FixedPoint#(ai, af) cos;
  49.   FixedPoint#(ai, af) sin;
  50.  } CosSinPair#(type ai, type af) deriving (Bits, Eq);
  52. // use this type to specify the mode the cordic is operating at
  53. // RotateMode = calculate cos, sin
  54. // VectorMode = calculate arctan
  55. typedef enum {RotateMode, VectorMode} OpMode deriving (Bits, Eq);
  57. // data used at each stage of the CORDIC operations
  58. typedef struct
  59. {
  60.  FixedPoint#(2, vfsz) x;      // coord x
  61.  FixedPoint#(2, vfsz) y;      // coord y
  62.  FixedPoint#(1, afsz) beta;   // angle
  63.  OpMode               mode;   // operation mode
  64.  Bit#(2)              quad;   // this show the quadrant of the input located    
  65.  } CORDICData#(numeric type vfsz, numeric type afsz) deriving (Bits, Eq);  
  67. // End of Data Types
  68. /////////////////////////////////////////////////////////////////////////////////////////
  71. /////////////////////////////////////////////////////////////////////////////////////////
  72. // Begin of Interfaces
  74. // visz = no. of bits for the integer part of the output values, 
  75. // vfsz = no. of bits for the fractional part of the output values
  76. // aisz = no. of bits for the integer part of the input angle, 
  77. // afsz = no. of bits for the fractional part of the input angle,
  78. interface CosAndSin#(numeric type visz, numeric type vfsz, numeric type aisz, numeric type afsz);
  80.   method Action putAngle(FixedPoint#(aisz,afsz) x); // input angle
  82.   method ActionValue#(CosSinPair#(visz,vfsz)) getCosSinPair(); // return tuple2 (cos(x),sin(x))
  84. endinterface
  86. // visz = no. of bits for the integer part of the input values, 
  87. // vfsz = no. of bits for the fractional part of the input values
  88. // aisz = no. of bits for the integer part of the output angle, 
  89. // afsz = no. of bits for the fractional part of the output angle,
  90. interface ArcTan#(numeric type visz, numeric type vfsz, numeric type aisz, numeric type afsz);
  92.   method Action putXY(FixedPoint#(visz,vfsz) x, FixedPoint#(visz,vfsz) y); // val of x, y coordinate
  94.   method ActionValue#(FixedPoint#(aisz,afsz)) getArcTan(); // return arcTan(y/x) 
  96. endinterface
  98. // vfsz = no of bits to represent the fractional part of values
  99. // afsz = no of bits to represent the fractional part of angle
  100. interface CORDIC#(numeric type vfsz, numeric type afsz);
  102.   method Action putCORDICData(CORDICData#(vfsz,afsz) x);
  104.   method ActionValue#(CORDICData#(vfsz,afsz)) getCORDICData();
  106. endinterface
  108. // End of Interfaces
  109. /////////////////////////////////////////////////////////////////////////////////////////
  112. /////////////////////////////////////////////////////////////////////////////////////////
  113. // Begin of Functions
  116. // begin of auxiliary functions
  117. function CORDICData#(vfsz,afsz) executeStage(Bit#(4) stage, CORDICData#(vfsz, afsz) inData)
  118.   provisos (Arith#(FixedPoint#(2,vfsz)), 
  119.     Arith#(FixedPoint#(1,afsz)));
  121.       Vector#(16, FixedPoint#(1,afsz)) arcTan_LUT = Vector::toVector(List::cons(
  122.   fromRational(450000000000,3600000000000), List::cons(  //45.0000000000
  123.                                                   fromRational(265650511771,3600000000000), List::cons(  //26.5650511771
  124.                                                   fromRational(140362434679,3600000000000), List::cons(  //14.0362434679
  125.                                                   fromRational( 71250163489,3600000000000), List::cons(  // 7.1250163489
  126.                                                   fromRational( 35763343749,3600000000000), List::cons(  // 3.5763343749
  127.                                                   fromRational( 17899106082,3600000000000), List::cons(  // 1.7899106082
  128.                                                   fromRational(  8951737102,3600000000000), List::cons(  // 0.8951737102
  129.                                                   fromRational(  4476141709,3600000000000), List::cons(  // 0.4476141709
  130.                                                   fromRational(  2238105004,3600000000000), List::cons(  // 0.2238105004
  131.                                                   fromRational(  1119056771,3600000000000), List::cons(  // 0.1119056771
  132.                                                   fromRational(   559528919,3600000000000), List::cons(  // 0.0559528919
  133.                                                   fromRational(   279764526,3600000000000), List::cons(  // 0.0279764526
  134.                                                   fromRational(   139882271,3600000000000), List::cons(  // 0.0139882271
  135.                                                   fromRational(    69941138,3600000000000), List::cons(  // 0.0069941138
  136.                                                   fromRational(    34970569,3600000000000), List::cons(  // 0.0034970569
  137.                                                   fromRational(    17485284,3600000000000),        // 0.0017485284
  138.                                                   List::nil)))))))))))))))));
  139.       let rotateClockwise = (inData.mode == RotateMode) ? (inData.beta < 0) : (inData.y > 0); // rotation depends on operation
  140.       let gamma = arcTan_LUT[stage];
  141.       let shiftedx = inData.x >> stage; //signed right shift
  142.       let shiftedy = inData.y >> stage; //signed right shift
  143.       let newx = inData.x + (rotateClockwise ? shiftedy : negate(shiftedy));
  144.       let newy = inData.y + (rotateClockwise ? negate(shiftedx) : shiftedx);
  145.       let newBeta = inData.beta + (rotateClockwise ? gamma : negate(gamma));
  146.       return CORDICData{x:newx, y:newy, beta:newBeta, mode:inData.mode, quad:inData.quad};
  147. endfunction
  149. function CORDICData#(vfsz,afsz) execute(CORDICData#(vfsz,afsz) inData, Integer steps)
  150.   provisos (Arith#(FixedPoint#(1,afsz)),
  151.     Arith#(FixedPoint#(2,vfsz)));
  153.       CORDICData#(vfsz,afsz) v = inData;
  154.       Integer maxN = (steps > 16) ? 15 : steps - 1;
  155.       for(Integer i = 0; i < maxN ; i = i + 1)
  156. begin
  157.    Bit#(4) stage = fromInteger(i);
  158.    v = executeStage(stage, v);
  159. end
  160.       return v;
  161. endfunction // CORDICData
  163. // right shift
  164. function FixedPoint#(1,rf) convertFP(FixedPoint#(ni,nf) x)
  165.   provisos (Add#(xxA, nf, rf), 
  166.     Add#(xxA, 1, ni), 
  167.     Add#(xxA, TAdd#(ni,nf), TAdd#(ni,rf)),
  168.     Add#(xxB, TAdd#(1,rf), TAdd#(ni,rf)));
  170.       FixedPoint#(ni,rf) inX = fxptSignExtend(x) >> valueOf(xxA);
  171.       FixedPoint#(1,rf) outX =  fxptTruncate(inX); // as if doing right shift by xxA  
  172.       return outX;
  173. endfunction // FixedPoint
  176. // setup the input for cordic data in rotation mode
  177. function CORDICData#(vfsz,afsz) getRotateModeInData(FixedPoint#(aisz,afsz) beta)
  178.   provisos (Add#(xxA,1,aisz),
  179.     Add#(2,afszl2,afsz),
  180.     Add#(3,afszl2,TAdd#(1,afsz)),
  181.     Add#(aisz,afsz,TAdd#(aisz,afsz)),
  182.     Literal#(FixedPoint#(2,vfsz)));
  184.       Bit#(afsz) tempBeta = pack(fxptGetFrac(beta));
  185.       Tuple2#(Bit#(2), Bit#(afszl2)) {inQuad, betaLSBs} = split(pack(tempBeta));
  186.       FixedPoint#(1,afsz) inBeta = unpack(zeroExtend(betaLSBs));      
  187.       return CORDICData{x:fromRational(607253,1000000),y:0,beta:inBeta,mode:RotateMode, quad:inQuad};
  188. endfunction // CORDICData
  190. // setup the input for cordic data in vector mode
  191. function CORDICData#(rfsz,afsz) getVectorModeInData(FixedPoint#(visz,vfsz) a, FixedPoint#(visz,vfsz) b)
  192.   provisos (Add#(xxA, vfsz, rfsz), 
  193.     Add#(xxA, 1, visz), 
  194.     Add#(xxA, TAdd#(visz,vfsz), TAdd#(visz,rfsz)),
  195.     Add#(xxB, TAdd#(1,rfsz), TAdd#(visz,rfsz)),
  196.     Add#(1,TAdd#(1,rfsz),TAdd#(2,rfsz)),
  197.     Arith#(FixedPoint#(1,rfsz)),
  198.     Literal#(FixedPoint#(1,afsz)));
  200.       
  201.       FixedPoint#(1,rfsz) x = convertFP(a); // right shifD      FixedPoint#(1,rf) inY = convertFP(y);
  202.       FixedPoint#(1,rfsz) y = convertFP(b); // right shifD      FixedPoint#(1,rf) inY = convertFP(y);
  203.       let xIsNeg = x < 0;
  204.       let yIsNeg = y < 0;
  205.       let absX = xIsNeg ? negate(x) : x;
  206.       let absY = yIsNeg ? negate(y) : y;
  207.       let swap = absY > absX;
  208.       let {inX, inY} = swap ? tuple2(absY, x) : tuple2(absX, y);
  209.       Bit#(2) inQuad = {pack(swap), pack(swap ? yIsNeg : xIsNeg)};
  210.       return CORDICData{x:fxptSignExtend(inX),y:fxptSignExtend(inY),beta:0,mode:VectorMode, quad:inQuad};
  211. endfunction // CORDICData
  213. // setup the input for cordic
  214. function CORDICData#(vfsz,afsz) getCORDICInData(CORDICData#(vfsz,afsz) inData)
  215.   provisos (Add#(1, afsz, TAdd#(1, afsz)),
  216.     Add#(1, TAdd#(1, vfsz), TAdd#(2, vfsz)),
  217.     Add#(2, afszl2, afsz),
  218.     Add#(3, afszl2, TAdd#(1, afsz)),
  219.     Arith#(FixedPoint::FixedPoint#(1, vfsz)),
  220.     Literal#(FixedPoint::FixedPoint#(2, vfsz)));
  222.       FixedPoint#(1,vfsz) inX = fxptTruncate(inData.x);
  223.       FixedPoint#(1,vfsz) inY = fxptTruncate(inData.y);
  224.       let result = (inData.mode == RotateMode) ? 
  225.    getRotateModeInData(inData.beta) : 
  226.    getVectorModeInData(inX,inY);
  227.       return result;
  228. endfunction // CORDICData
  230. // translate the cordic data into result rotation mode
  231. function CosSinPair#(visz,vfsz) getRotateModeOutData(CORDICData#(vfsz,afsz) cData)
  232.   provisos (Add#(1,TAdd#(1,vfsz),TAdd#(2,vfsz)),
  233.     Add#(xxA,1,visz),
  234.     Add#(xxA,TAdd#(1,vfsz),TAdd#(visz,vfsz)),
  235.     Arith#(FixedPoint#(1,vfsz)),
  236.     Literal#(FixedPoint#(2,vfsz)));
  237.       
  238.       FixedPoint#(1,vfsz) max = maxBound;
  239.       let tempX = (cData.x >= 1) ? max : ((cData.x < 0) ? 0 : fxptTruncate(cData.x)); // overflow detection
  240.       let tempY = (cData.y >= 1) ? max : ((cData.y < 0) ? 0 : fxptTruncate(cData.y)); // overflow detection
  241.       let negateX = negate(tempX);
  242.       let negateY = negate(tempY);
  243.       let {cosV, sinV} = case (cData.quad)
  244.    2'b00: tuple2(tempX, tempY);
  245.    2'b01: tuple2(negateY, tempX);
  246.    2'b10: tuple2(negateX, negateY);
  247.    2'b11: tuple2(tempY, negateX);
  248.  endcase; // case(cData.quad)
  249.       return CosSinPair{cos: fxptSignExtend(cosV), sin: fxptSignExtend(sinV)};    
  250. endfunction // CORDICData
  254. // translate the cordic data into result vector mode
  255. // output range: (-0.5,0.5]
  256. function FixedPoint#(aisz,afsz) getVectorModeOutData(CORDICData#(vfsz,afsz) cData)
  257.   provisos (Add#(xxA,1,aisz),
  258.     Add#(xxA,TAdd#(1,afsz),TAdd#(aisz,afsz)),
  259.     Arith#(FixedPoint#(1,afsz)));
  261.       let angle = cData.beta;
  262.       Tuple2#(FixedPoint#(1,afsz),FixedPoint#(1,afsz))
  263. tempTuple = case (cData.quad)
  264. 2'b00 : tuple2(0, angle);
  265. 2'b01 : tuple2(((angle < 0) ? fromRational(-1,2) : fromRational(1,2)), negate(angle));
  266. 2'b10 : tuple2(fromRational(1,4), negate(angle));
  267. 2'b11 : tuple2(fromRational(-1,4), angle);
  268.       endcase;
  269.       FixedPoint#(1,afsz) result = tpl_1(tempTuple) + tpl_2(tempTuple);
  270.       return fxptSignExtend(result);
  271. endfunction // CORDICData
  273. // translate the cordic data into result
  274. function CORDICData#(vfsz,afsz) getCORDICOutData(CORDICData#(vfsz,afsz) cData)
  275.   provisos (Add#(1,TAdd#(1,vfsz),TAdd#(2,vfsz)),
  276.     Arith#(FixedPoint#(1,vfsz)),
  277.     Arith#(FixedPoint#(1,afsz)),
  278.     Literal#(FixedPoint#(2,vfsz)));
  280.       CosSinPair#(1,vfsz) cosSinPair = getRotateModeOutData(cData);
  281.       FixedPoint#(2,vfsz) cosV = fxptSignExtend(cosSinPair.cos);
  282.       FixedPoint#(2,vfsz) sinV = fxptSignExtend(cosSinPair.sin);
  283.       let atan = getVectorModeOutData(cData);
  284.       return CORDICData{x:cosV, y:sinV, beta:atan, mode:cData.mode, quad:cData.quad};
  285. endfunction // CORDICData
  288. // end of auxiliary functions
  290. // input: angle (in terms of no of full circle, e.g. pi = 1/2)
  291. //        steps (no of iterations executed, max 16)
  292. // output: tuple2(cos(angle), sin(angle))
  293. function CosSinPair#(ni, nf) getCosSinPair(FixedPoint#(hi, hf) angle, Integer steps)
  294.   provisos (Add#(xxA,1,hi),
  295.     Add#(2,hfl2,hf),
  296.     Add#(3,hfl2,TAdd#(1,hf)),
  297.     Add#(hi,hf,TAdd#(hi,hf)),
  298.     Literal#(FixedPoint#(2,nf)),
  299.     Add#(1,TAdd#(1,nf),TAdd#(2,nf)),
  300.     Add#(xxB,1,ni),
  301.     Add#(xxB,TAdd#(1,nf),TAdd#(ni,nf)),
  302.     Arith#(FixedPoint#(1,nf)),
  303.     Literal#(FixedPoint#(2,nf)),
  304.     Arith#(FixedPoint#(1,hf)),
  305.     Arith#(FixedPoint#(2,nf)));
  306.           
  307.       CORDICData#(nf,hf) inData  = getRotateModeInData(angle);
  308.       CORDICData#(nf,hf) outData = execute(inData, steps);
  309.       CosSinPair#(ni,nf)  result  = getRotateModeOutData(outData);
  310.       return CosSinPair{cos: result.cos, sin: result.sin};
  311. endfunction // CosSinPair
  314. // input: angle (in terms of no of full circle, e.g. pi = 1/2)
  315. //        steps (no of iterations executed, max 16)
  316. // output: cos(angle)
  317. function FixedPoint#(ni, nf) cos(FixedPoint#(hi, hf) angle, Integer steps)
  318.   provisos (Add#(xxA,1,hi),
  319.     Add#(2,hfl2,hf),
  320.     Add#(3,hfl2,TAdd#(1,hf)),
  321.     Add#(hi,hf,TAdd#(hi,hf)),
  322.     Literal#(FixedPoint#(2,nf)),
  323.     Add#(1,TAdd#(1,nf),TAdd#(2,nf)),
  324.     Add#(xxB,1,ni),
  325.     Add#(xxB,TAdd#(1,nf),TAdd#(ni,nf)),
  326.     Arith#(FixedPoint#(1,nf)),
  327.     Literal#(FixedPoint#(2,nf)),
  328.     Arith#(FixedPoint#(1,hf)),
  329.     Arith#(FixedPoint#(2,nf)));
  331.       let result = getCosSinPair(angle, steps);
  332.       return result.cos;
  333. endfunction // FixedPoint
  336. // input: angle (in terms of no of full circle, e.g. pi = 1/2)
  337. //        steps (no of iterations executed, max 16)
  338. // output: sin(angle)
  339. function FixedPoint#(ni, nf) sin(FixedPoint#(hi, hf) angle, Integer precision)
  340.   provisos (Add#(xxA,1,hi),
  341.     Add#(2,hfl2,hf),
  342.     Add#(3,hfl2,TAdd#(1,hf)),
  343.     Add#(hi,hf,TAdd#(hi,hf)),
  344.     Literal#(FixedPoint#(2,nf)),
  345.     Add#(1,TAdd#(1,nf),TAdd#(2,nf)),
  346.     Add#(xxB,1,ni),
  347.     Add#(xxB,TAdd#(1,nf),TAdd#(ni,nf)),
  348.     Arith#(FixedPoint#(1,nf)),
  349.     Literal#(FixedPoint#(2,nf)),
  350.     Arith#(FixedPoint#(1,hf)),
  351.     Arith#(FixedPoint#(2,nf)));
  353.       let result = getCosSinPair(angle, precision);
  354.       return result.sin;
  355. endfunction // FixedPoint
  357. // input: x, y (coord value for x, y axes)
  358. //        precision (no of iterations executed, max 16)
  359. // output: atan(y/x) (in terms of no of full circle, e.g. pi = 1/2) 
  360. function FixedPoint#(hi, hf) atan(FixedPoint#(ni, nf) x, FixedPoint#(ni,nf) y, Integer steps)
  361.   provisos (Add#(xxA, nf, rf), 
  362.     Add#(xxA, TAdd#(ni,nf), TAdd#(ni,rf)),
  363.     Add#(xxA, 1, ni),
  364.     Add#(xxB, TAdd#(1,rf), TAdd#(ni,rf)),
  365.     Add#(xxC, TAdd#(1,hf), TAdd#(hi,hf)),
  366.     Add#(xxC, 1, hi),
  367.     Add#(1,TAdd#(1,rf),TAdd#(2,rf)),
  368.     Arith#(FixedPoint#(1,rf)),
  369.     Arith#(FixedPoint#(1,hf)),
  370.     Arith#(FixedPoint#(2,rf)),
  371.     Literal#(FixedPoint#(1,hf)));
  373.       CORDICData#(rf,hf) inData  = getVectorModeInData(x,y);
  374.       CORDICData#(rf,hf) outData = execute(inData, steps);
  375.       FixedPoint#(1,hf)  result  = getVectorModeOutData(outData);
  376.       return fxptSignExtend(result);
  377. endfunction // FixedPoint
  378.       
  379. // End of Functions
  380. /////////////////////////////////////////////////////////////////////////////////////////
  383. /////////////////////////////////////////////////////////////////////////////////////////
  384. // Begin of Modules
  386. module [Module] mkCORDIC#(Module#(Pipeline#(CORDICData#(vfsz,afsz))) mkP)
  387.               (CORDIC#(vfsz,afsz));
  389.    Pipeline#(CORDICData#(vfsz,afsz)) p <- mkP(); 
  390.   
  391.    method Action putCORDICData(CORDICData#(vfsz,afsz) x);
  392.    begin
  393.       p.put(x);
  394.    end
  395.    endmethod
  397.    // output to cyclic extend queue method
  399.    method ActionValue#(CORDICData#(vfsz,afsz)) getCORDICData();
  400.    begin
  401.       let result <- p.get();
  402.       return result;
  403.    end
  404.    endmethod
  406. endmodule
  408. // for making cordic pipeline
  409. module [Module] mkCORDIC_Pipe#(Integer numStages, Integer step)(CORDIC#(vfsz,afsz))
  410.   provisos (Arith#(FixedPoint#(2, vfsz)),
  411.     Add#(1, afsz, TAdd#(1, afsz)),
  412.     Arith#(FixedPoint#(1, vfsz)),
  413.     Add#(3, afszl2, TAdd#(1, afsz)),
  414.     Add#(2, afszl2, afsz),
  415.     Add#(1, TAdd#(1, vfsz), TAdd#(2, vfsz)));
  416.    
  417.    CORDIC#(vfsz,afsz) cordic <- mkCORDIC(mkPipeline_Sync(numStages, step, executeStage));
  419.    method Action putCORDICData(CORDICData#(vfsz,afsz) x);
  420.       cordic.putCORDICData(getCORDICInData(x));
  421.    endmethod
  422.      
  423.    method ActionValue#(CORDICData#(vfsz,afsz)) getCORDICData();
  424.       let outData <- cordic.getCORDICData();
  425.       return getCORDICOutData(outData);
  426.    endmethod
  428. endmodule
  430. // for making CosAndSin pipeline
  431. module [Module] mkCosAndSin_Pipe#(Integer numStages, Integer step)(CosAndSin#(visz, vfsz, aisz, afsz))
  432.   provisos (Arith#(FixedPoint#(2, vfsz)),
  433.     Arith#(FixedPoint#(1, afsz)),
  434.     Add#(xxA, 1, aisz),
  435.     Add#(2, afszl2, afsz),
  436.     Add#(3, afszl2, TAdd#(1, afsz)),
  437.     Add#(aisz, afsz, TAdd#(aisz, afsz)),
  438.     Add#(1, TAdd#(1, vfsz), TAdd#(2, vfsz)),
  439.     Add#(xxB, 1, visz),
  440.     Add#(xxB, TAdd#(1, vfsz), TAdd#(visz, vfsz)),
  441.     Arith#(FixedPoint#(1, vfsz)));
  442.    
  443.    CORDIC#(vfsz,afsz) cordic <- mkCORDIC(mkPipeline_Sync(numStages, step, executeStage));
  445.    method Action putAngle(FixedPoint#(aisz,afsz) beta);
  446.       cordic.putCORDICData(getRotateModeInData(beta));
  447.    endmethod
  448.      
  449.    method ActionValue#(CosSinPair#(visz,vfsz)) getCosSinPair();
  450.       let outData <- cordic.getCORDICData();
  451.       return getRotateModeOutData(outData);
  452.    endmethod
  454. endmodule
  456. // for making ArcTan  pipeline
  457. module [Module] mkArcTan_Pipe#(Integer numStages, Integer step)(ArcTan#(visz,vfsz,aisz,afsz))
  458.   provisos (Add#(xxA, vfsz, rf), 
  459.     Add#(xxA, TAdd#(visz,vfsz), TAdd#(visz,rf)),
  460.     Add#(xxA, 1, visz),
  461.     Add#(xxB, TAdd#(1,rf), TAdd#(visz,rf)),
  462.     Add#(xxC, TAdd#(1,afsz), TAdd#(aisz,afsz)),
  463.     Add#(xxC, 1, aisz),
  464.     Add#(1,TAdd#(1,rf),TAdd#(2,rf)),
  465.     Arith#(FixedPoint#(1,rf)),
  466.     Arith#(FixedPoint#(1,afsz)),
  467.     Arith#(FixedPoint#(2,rf)),
  468.     Literal#(FixedPoint#(1,afsz)));
  470.    
  471.    CORDIC#(rf,afsz) cordic <- mkCORDIC(mkPipeline_Sync(numStages, step, executeStage));
  473.    method Action putXY(FixedPoint#(visz,vfsz) x, FixedPoint#(visz,vfsz) y);
  474.       CORDICData#(rf,afsz) inData = getVectorModeInData(x,y);
  475.       cordic.putCORDICData(inData);
  476.    endmethod
  477.      
  478.    method ActionValue#(FixedPoint#(aisz,afsz)) getArcTan();
  479.       let outData <- cordic.getCORDICData();
  480.       return getVectorModeOutData(outData);
  481.    endmethod
  483. endmodule // mkArcTan_Pipe
  485. // End of Modules
  486. /////////////////////////////////////////////////////////////////////////////////////////