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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
mathALib.s
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：33k
源码类别：

VxWorks

开发平台：

C/C++

mathALib.s：源码内容
  1. /* mathALib.s - C-callable floating-point math entry points */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  5. /*
  6. modification history 
  7. --------------------
  8. 01d,05sep01,hdn  added FUNC/FUNC_LABEL GTEXT/GDATA macros
  9.  replaced .align with .balign
  10.  removed cosh, sinh, tanh for one in libc/math
  11. 01c,16jun93,hdn  updated to 5.1.
  12. 01b,14oct92,hdn  aligned all functions.
  13. 01a,16sep92,hdn  written by modifying Tron's mathALib.s
  14. */
  16. /*
  17. DESCRIPTION
  18. This library provides a C interface to the high-level math functions,
  19. provided either by an i80387 floating-point coprocessor or
  20. a software floating point emulation library.  The appropriate function
  21. is called, based on whether mathHardInit() or mathSoftInit() has been
  22. called.
  24. All angle-related parameters and return values are expressed in radians.  
  25. Functions capable of errors will set errno upon an error. All functions
  26. included in this library whos names correspond to the ANSI C specification
  27. are, indeed, ANSI-compatable. In the spirit of ANSI, HUGE_VAL is now
  28. supported.
  30. SEE ALSO:
  31. fppLib (1), floatLib (1), The C Programming Language - Second Edition
  33. INCLUDE FILE: math.h
  35. */
  37. #define _ASMLANGUAGE
  38. #include "vxWorks.h"
  39. #include "asm.h"
  40. #include "errno.h"
  43. .data
  44. .globl FUNC(copyright_wind_river)
  45. .long FUNC(copyright_wind_river)
  48. /* externals */
  50. .globl FUNC(logMsg)
  53. /* internals */
  55.         .globl  GTEXT(acos) /* double-precision functions */
  56.         .globl  GTEXT(asin)
  57.         .globl  GTEXT(atan)
  58. .globl  GTEXT(atan2)
  59. .globl  GTEXT(cbrt)
  60. .globl  GTEXT(ceil)
  61.         .globl  GTEXT(cos)
  62.         .globl  GTEXT(exp)
  63.         .globl  GTEXT(fabs)
  64. .globl  GTEXT(floor)
  65. .globl  GTEXT(fmod)
  66. .globl GTEXT(hypot)
  67. .globl  GTEXT(infinity)
  68. .globl  GTEXT(irint)
  69. .globl  GTEXT(iround)
  70.         .globl  GTEXT(log)
  71.         .globl  GTEXT(log2)
  72.         .globl  GTEXT(log10)
  73.         .globl  GTEXT(pow)
  74. .globl  GTEXT(round)
  75.         .globl  GTEXT(sin)
  76. .globl  GTEXT(sincos)
  77.         .globl  GTEXT(sqrt)
  78.         .globl  GTEXT(tan)
  79. .globl  GTEXT(trunc)
  81.         .globl  GTEXT(facos) /* single-precision functions */
  82.         .globl  GTEXT(fasin)
  83.         .globl  GTEXT(fatan)
  84. .globl  GTEXT(fatan2)
  85. .globl  GTEXT(fcbrt)
  86. .globl  GTEXT(fceil)
  87.         .globl  GTEXT(fcos)
  88.         .globl  GTEXT(fcosh)
  89.         .globl  GTEXT(fexp)
  90.         .globl  GTEXT(ffabs)
  91. .globl  GTEXT(ffloor)
  92. .globl  GTEXT(ffmod)
  93. .globl GTEXT(fhypot)
  94. .globl  GTEXT(finfinity)
  95. .globl  GTEXT(firint)
  96. .globl  GTEXT(firound)
  97.         .globl  GTEXT(flog)
  98.         .globl  GTEXT(flog2)
  99.         .globl  GTEXT(flog10)
  100.         .globl  GTEXT(fpow)
  101. .globl  GTEXT(fround)
  102.         .globl  GTEXT(fsin)
  103. .globl  GTEXT(fsincos)
  104.         .globl  GTEXT(fsinh)
  105.         .globl  GTEXT(fsqrt)
  106.         .globl  GTEXT(ftan)
  107.         .globl  GTEXT(ftanh)
  108. .globl  GTEXT(ftrunc)
  110. .globl GTEXT(mathErrNoInit) /* default routine (log error msg) */
  112. .globl  GDATA(mathAcosFunc) /* double-precision function pointers */
  113. .globl  GDATA(mathAsinFunc)
  114. .globl  GDATA(mathAtanFunc)
  115. .globl  GDATA(mathAtan2Func)
  116. .globl  GDATA(mathCbrtFunc)
  117. .globl  GDATA(mathCeilFunc)
  118. .globl  GDATA(mathCosFunc)
  119. .globl  GDATA(mathCoshFunc)
  120. .globl  GDATA(mathExpFunc)
  121. .globl  GDATA(mathFabsFunc)
  122. .globl  GDATA(mathFloorFunc)
  123. .globl  GDATA(mathFmodFunc)
  124. .globl  GDATA(mathHypotFunc)
  125. .globl  GDATA(mathInfinityFunc)
  126. .globl  GDATA(mathIrintFunc)
  127. .globl  GDATA(mathIroundFunc)
  128. .globl  GDATA(mathLogFunc)
  129. .globl  GDATA(mathLog2Func)
  130. .globl  GDATA(mathLog10Func)
  131. .globl  GDATA(mathPowFunc)
  132. .globl  GDATA(mathRoundFunc)
  133. .globl  GDATA(mathSinFunc)
  134. .globl  GDATA(mathSincosFunc)
  135. .globl  GDATA(mathSinhFunc)
  136. .globl  GDATA(mathSqrtFunc)
  137. .globl  GDATA(mathTanFunc)
  138. .globl  GDATA(mathTanhFunc)
  139. .globl  GDATA(mathTruncFunc)
  141. .globl  GDATA(mathFacosFunc) /* single-precision function pointers */
  142. .globl  GDATA(mathFasinFunc)
  143. .globl  GDATA(mathFatanFunc)
  144. .globl  GDATA(mathFatan2Func)
  145. .globl  GDATA(mathFcbrtFunc)
  146. .globl  GDATA(mathFceilFunc)
  147. .globl  GDATA(mathFcosFunc)
  148. .globl  GDATA(mathFcoshFunc)
  149. .globl  GDATA(mathFexpFunc)
  150. .globl  GDATA(mathFfabsFunc)
  151. .globl  GDATA(mathFfloorFunc)
  152. .globl  GDATA(mathFfmodFunc)
  153. .globl  GDATA(mathFhypotFunc)
  154. .globl  GDATA(mathFinfinityFunc)
  155. .globl  GDATA(mathFirintFunc)
  156. .globl  GDATA(mathFiroundFunc)
  157. .globl  GDATA(mathFlogFunc)
  158. .globl  GDATA(mathFlog2Func)
  159. .globl  GDATA(mathFlog10Func)
  160. .globl  GDATA(mathFpowFunc)
  161. .globl  GDATA(mathFroundFunc)
  162. .globl  GDATA(mathFsinFunc)
  163. .globl  GDATA(mathFsincosFunc)
  164. .globl  GDATA(mathFsinhFunc)
  165. .globl  GDATA(mathFsqrtFunc)
  166. .globl  GDATA(mathFtanFunc)
  167. .globl  GDATA(mathFtanhFunc)
  168. .globl  GDATA(mathFtruncFunc)
  171. .data
  172. .balign 16
  174. FUNC_LABEL(mathAcosFunc) /* double-precision function pointers */
  175. .long FUNC(mathErrNoInit)
  176. FUNC_LABEL(mathAsinFunc)
  177. .long FUNC(mathErrNoInit)
  178. FUNC_LABEL(mathAtanFunc)
  179. .long FUNC(mathErrNoInit)
  180. FUNC_LABEL(mathAtan2Func)
  181. .long FUNC(mathErrNoInit)
  182. FUNC_LABEL(mathCbrtFunc)
  183. .long FUNC(mathErrNoInit)
  184. FUNC_LABEL(mathCeilFunc)
  185. .long FUNC(mathErrNoInit)
  186. FUNC_LABEL(mathCosFunc)
  187. .long FUNC(mathErrNoInit)
  188. FUNC_LABEL(mathCoshFunc)
  189. .long FUNC(mathErrNoInit)
  190. FUNC_LABEL(mathExpFunc)
  191. .long FUNC(mathErrNoInit)
  192. FUNC_LABEL(mathFabsFunc)
  193. .long FUNC(mathErrNoInit)
  194. FUNC_LABEL(mathFloorFunc)
  195. .long FUNC(mathErrNoInit)
  196. FUNC_LABEL(mathFmodFunc)
  197. .long FUNC(mathErrNoInit)
  198. FUNC_LABEL(mathHypotFunc)
  199. .long FUNC(mathErrNoInit)
  200. FUNC_LABEL(mathInfinityFunc)
  201. .long FUNC(mathErrNoInit)
  202. FUNC_LABEL(mathIrintFunc)
  203. .long FUNC(mathErrNoInit)
  204. FUNC_LABEL(mathIroundFunc)
  205. .long FUNC(mathErrNoInit)
  206. FUNC_LABEL(mathLogFunc)
  207. .long FUNC(mathErrNoInit)
  208. FUNC_LABEL(mathLog2Func)
  209. .long FUNC(mathErrNoInit)
  210. FUNC_LABEL(mathLog10Func)
  211. .long FUNC(mathErrNoInit)
  212. FUNC_LABEL(mathPowFunc)
  213. .long FUNC(mathErrNoInit)
  214. FUNC_LABEL(mathRoundFunc)
  215. .long FUNC(mathErrNoInit)
  216. FUNC_LABEL(mathSinFunc)
  217. .long FUNC(mathErrNoInit)
  218. FUNC_LABEL(mathSincosFunc)
  219. .long FUNC(mathErrNoInit)
  220. FUNC_LABEL(mathSinhFunc)
  221. .long FUNC(mathErrNoInit)
  222. FUNC_LABEL(mathSqrtFunc)
  223. .long FUNC(mathErrNoInit)
  224. FUNC_LABEL(mathTanFunc)
  225. .long FUNC(mathErrNoInit)
  226. FUNC_LABEL(mathTanhFunc)
  227. .long FUNC(mathErrNoInit)
  228. FUNC_LABEL(mathTruncFunc)
  229. .long FUNC(mathErrNoInit)
  231. FUNC_LABEL(mathFacosFunc) /* single-precision function pointers */
  232. .long FUNC(mathErrNoInit)
  233. FUNC_LABEL(mathFasinFunc)
  234. .long FUNC(mathErrNoInit)
  235. FUNC_LABEL(mathFatanFunc)
  236. .long FUNC(mathErrNoInit)
  237. FUNC_LABEL(mathFatan2Func)
  238. .long FUNC(mathErrNoInit)
  239. FUNC_LABEL(mathFcbrtFunc)
  240. .long FUNC(mathErrNoInit)
  241. FUNC_LABEL(mathFceilFunc)
  242. .long FUNC(mathErrNoInit)
  243. FUNC_LABEL(mathFcosFunc)
  244. .long FUNC(mathErrNoInit)
  245. FUNC_LABEL(mathFcoshFunc)
  246. .long FUNC(mathErrNoInit)
  247. FUNC_LABEL(mathFexpFunc)
  248. .long FUNC(mathErrNoInit)
  249. FUNC_LABEL(mathFfabsFunc)
  250. .long FUNC(mathErrNoInit)
  251. FUNC_LABEL(mathFfloorFunc)
  252. .long FUNC(mathErrNoInit)
  253. FUNC_LABEL(mathFfmodFunc)
  254. .long FUNC(mathErrNoInit)
  255. FUNC_LABEL(mathFhypotFunc)
  256. .long FUNC(mathErrNoInit)
  257. FUNC_LABEL(mathFinfinityFunc)
  258. .long FUNC(mathErrNoInit)
  259. FUNC_LABEL(mathFirintFunc)
  260. .long FUNC(mathErrNoInit)
  261. FUNC_LABEL(mathFiroundFunc)
  262. .long FUNC(mathErrNoInit)
  263. FUNC_LABEL(mathFlogFunc)
  264. .long FUNC(mathErrNoInit)
  265. FUNC_LABEL(mathFlog2Func)
  266. .long FUNC(mathErrNoInit)
  267. FUNC_LABEL(mathFlog10Func)
  268. .long FUNC(mathErrNoInit)
  269. FUNC_LABEL(mathFpowFunc)
  270. .long FUNC(mathErrNoInit)
  271. FUNC_LABEL(mathFroundFunc)
  272. .long FUNC(mathErrNoInit)
  273. FUNC_LABEL(mathFsinFunc)
  274. .long FUNC(mathErrNoInit)
  275. FUNC_LABEL(mathFsincosFunc)
  276. .long FUNC(mathErrNoInit)
  277. FUNC_LABEL(mathFsinhFunc)
  278. .long FUNC(mathErrNoInit)
  279. FUNC_LABEL(mathFsqrtFunc)
  280. .long FUNC(mathErrNoInit)
  281. FUNC_LABEL(mathFtanFunc)
  282. .long FUNC(mathErrNoInit)
  283. FUNC_LABEL(mathFtanhFunc)
  284. .long FUNC(mathErrNoInit)
  285. FUNC_LABEL(mathFtruncFunc)
  286. .long FUNC(mathErrNoInit)
  288. FUNC_LABEL(mathErrNoInitString)
  289. .asciz "ERROR - floating point math not initialized!n"
  292.         .text
  293. .balign 16
  295. /*******************************************************************************
  296. *
  297. * acos - ANSI-compatable floating-point arc-cosine
  298. *
  299. * RETURNS: The arc-cosine in the range -pi/2 to pi/2 radians.
  301. * double acos (dblParam)
  302. *     double dblParam; /* angle in radians *
  304. */
  306. FUNC_LABEL(acos)
  307. movl FUNC(mathAcosFunc),%eax
  308. jmp *%eax /* jump, let that routine rts */
  310. /*******************************************************************************
  311. *
  312. * asin - ANSI-compatable floating-point arc-sine
  313. *
  314. * RETURNS: The arc-sine in the range 0.0 to pi radians.
  315. * 
  316. * SEE ALSO: 
  317. * floatLib (1), "The C Programming Language - Second Edition"
  319. * double asin (dblParam)
  320. *     double dblParam; /* angle in radians *
  322. */
  324. .balign 16,0x90
  325. FUNC_LABEL(asin)
  326. movl FUNC(mathAsinFunc),%eax
  327. jmp *%eax /* jump, let that routine rts */
  329. /*******************************************************************************
  330. *
  331. * atan - ANSI-compatable floating-point arc-tangent
  332. *
  333. * RETURNS: The arc-tangent of dblParam in the range -pi/2 to pi/2.
  334. *
  335. * SEE ALSO: floatLib (1), acos (2), asin (2)
  337. * double atan (dblParam)
  338. *     double dblParam; /* angle in radians *
  340. */
  342. .balign 16,0x90
  343. FUNC_LABEL(atan)
  344. movl FUNC(mathAtanFunc),%eax
  345. jmp *%eax /* jump, let that routine rts */
  347. /*******************************************************************************
  348. *
  349. * atan2 - function returns the arc tangent of (dblY/dblX) 
  350. *
  351. * RETURNS:
  352. *    The arc-tangent of (dblY/dblX) in the range -pi to pi.
  353. *
  354. * SEE ALSO: 
  355. * floatLib (1), "The C Programming Language - Second Edition"
  357. * double atan2 (dblY, dblX)
  358. *     double dblY; /* Y *
  359. *     double dblX; /* X *
  361. */
  363. .balign 16,0x90
  364. FUNC_LABEL(atan2)
  365. movl FUNC(mathAtan2Func),%eax
  366. jmp *%eax /* jump, let that routine rts */
  368. /*******************************************************************************
  369. *
  370. * cbrt - floating-point cube root
  371. *
  372. * This routine takes a double-precision floating point parameter
  373. * and returns the double-precision cube root.
  374. *
  375. * RETURNS: double-precision cube root
  377. * double cbrt (dblParam)
  378. *     double dblParam;  /* argument *
  380. */
  382. .balign 16,0x90
  383. FUNC_LABEL(cbrt)
  384. movl FUNC(mathCbrtFunc),%eax
  385. jmp *%eax /* jump, let that routine rts */
  387. /*******************************************************************************
  388. *
  389. * ceil - ANSI-compatable floating-point ceiling
  390. *
  391. * Performs a 'round-to-positive-infinity'
  392. *
  393. * RETURNS: 
  394. * The least integral value greater than or equal to dblParam,
  395. * result is returned in double precision.
  396. *
  397. * SEE ALSO: 
  398. * floatLib (1), "The C Programming Language - Second Edition"
  400. * double ceil (dblParam)
  401. *     double dblParam; /* argument *
  403. */
  405. .balign 16,0x90
  406. FUNC_LABEL(ceil)
  407. movl FUNC(mathCeilFunc),%eax
  408. jmp *%eax /* jump, let that routine rts */
  410. /*******************************************************************************
  411. *
  412. * cos - ANSI-compatable floating-point cosine
  413. *
  414. * RETURNS: the cosine of the radian argument dblParam
  415. *
  416. * SEE ALSO: 
  417. * floatLib (1), sin (2), tan(2),
  418. * "The C Programming Language - Second Edition"
  420. * double cos (dblParam)
  421. *     double dblParam; /* angle in radians *
  423. */
  425. .balign 16,0x90
  426. FUNC_LABEL(cos)
  427. movl FUNC(mathCosFunc),%eax
  428. jmp *%eax /* jump, let that routine rts */
  430. /*******************************************************************************
  431. *
  432. * exp - exponential function
  433. *
  434. * RETURNS:
  435. *    Floating-point inverse natural logarithm (e ** (dblExponent)).
  436. *
  437. * SEE ALSO: 
  438. * floatLib (1), "The C Programming Language - Second Edition"
  440. * double exp (dblExponent)
  441. *     double dblExponent; /* argument *
  443. */
  445. .balign 16,0x90
  446. FUNC_LABEL(exp)
  447. movl FUNC(mathExpFunc),%eax
  448. jmp *%eax /* jump, let that routine rts */
  450. /*******************************************************************************
  451. *
  452. * fabs - ANSI-compatable floating-point absolute value
  453. *
  454. * RETURNS: The floating-point absolute value of dblParam.
  455. *
  456. * SEE ALSO: 
  457. * floatLib (1), "The C Programming Language - Second Edition"
  459. * double fabs (dblParam)
  460. *     double dblParam; /* argument *
  462. */
  464. .balign 16,0x90
  465. FUNC_LABEL(fabs)
  466. movl FUNC(mathFabsFunc),%eax
  467. jmp *%eax /* jump, let that routine rts */
  469. /*******************************************************************************
  470. *
  471. * floor - ANSI-compatable floating-point floor
  472. *
  473. * Performs a 'round-to-negative-infinity'.
  474. *
  475. * RETURNS: 
  476. * The largest integral value less than or equal to dblParam,
  477. * result is returned in double precision.
  478. *
  479. * SEE ALSO: 
  480. * floatLib (1), "The C Programming Language - Second Edition"
  481. *
  483. * double floor (dblParam)
  484. *     double dblParam; /* argument *
  486. */
  488. .balign 16,0x90
  489. FUNC_LABEL(floor)
  490. movl FUNC(mathFloorFunc),%eax
  491. jmp *%eax /* jump, let that routine rts */
  493. /*******************************************************************************
  494. *
  495. * fmod - ANSI-compatable floating-point modulus 
  496. *
  497. * RETURNS: 
  498. * Floating-point modulus of (dblParam / dblDivisor) with the sign of dblParam.  
  499. *
  500. * SEE ALSO: 
  501. * floatLib (1), "The C Programming Language - Second Edition"
  503. * double fmod (dblParam, dblDivisor)
  504. *     double dblParam; /* argument *
  505. *     double dblDivisor; /* divisor *
  507. */
  509. .balign 16,0x90
  510. FUNC_LABEL(fmod)
  511. movl FUNC(mathFmodFunc),%eax
  512. jmp *%eax /* jump, let that routine rts */
  514. /*******************************************************************************
  515. *
  516. * hypot - double-precision Euclidean distance (hypotenuse)
  517. *
  518. * This routine takes two input double-precision floating point
  519. * parameters and returns length of the corresponding Euclidean distance
  520. * (hypotenuse).
  521. *
  522. * The distance is calculated as
  523. * sqrt ((dblX * dblX) + (dblY * dblY))
  524. *
  525. * RETURNS: double-precision hypotenuse.
  526. *
  528. * double hypot (dblX, dblY)
  529. *     double dblX; /* argument *
  530. *     double dblY; /* argument *
  532. */
  534. .balign 16,0x90
  535. FUNC_LABEL(hypot)
  536. movl FUNC(mathHypotFunc),%eax
  537. jmp *%eax /* jump, let that routine rts */
  539. /********************************************************************************
  540. * infinity - return a very large double
  541. *
  542. * SEE ALSO: floatLib(1)
  543.  
  544. * double infinity ()
  546. */
  547.  
  548. .balign 16,0x90
  549. FUNC_LABEL(infinity)
  550. movl FUNC(mathInfinityFunc),%eax
  551. jmp *%eax /* jump, let that routine rts */
  554. /********************************************************************************
  555. * irint - convert double to integer
  556. *
  557. * Convert dblParam to an integer using the selected IEEE
  558. * rounding direction.
  559. *
  560. * CAVEAT:
  561. * The rounding direction is not pre-selectable
  562. * and is fixed for 'round-to-the-nearest'.
  563. *
  564. * SEE ALSO: floatLib (1)
  565.  
  566. * int irint (dblParam)
  567. *     double dblParam; /* argument *
  569. */
  570.  
  571. .balign 16,0x90
  572. FUNC_LABEL(irint)
  573. movl FUNC(mathIrintFunc),%eax
  574. jmp *%eax /* jump, let that routine rts */
  576. /*******************************************************************************
  577. *
  578. * iround - INTEGER floating-point rounding
  579. *
  580. * Performs a 'round-to-the-nearest' function.
  581. *
  582. * NOTE:
  583. * If dblParam is spaced evenly between two integers,
  584. * then the  even integer will be returned.
  586. * int iround (dblParam)
  587. *     double dblParam; /* argument *
  589. */
  591. .balign 16,0x90
  592. FUNC_LABEL(iround)
  593. movl FUNC(mathIroundFunc),%eax
  594. jmp *%eax /* jump, let that routine rts */
  596. /*******************************************************************************
  597. *
  598. * log - ANSI-compatable floating-point natural logarithm 
  599. *
  600. * RETURNS: The natural logarithm of dblParam.
  601. *
  602. * SEE ALSO: 
  603. * floatLib (1), "The C Programming Language - Second Edition"
  605. * double log (dblParam)
  606. *     double dblParam; /* argument *
  608. */
  610. .balign 16,0x90
  611. FUNC_LABEL(log)
  612. movl FUNC(mathLogFunc),%eax
  613. jmp *%eax /* jump, let that routine rts */
  615. /*******************************************************************************
  616. *
  617. * log10 - ANSI-compatable floating-point logarithm base 10 
  618. *
  619. * RETURNS: The logarithm (base 10) of dblParam.
  620. *
  621. * SEE ALSO: floatLib (1), log2 (2)
  623. * double log10 (dblParam)
  624. *     double dblParam; /* argument *
  626. */
  628. .balign 16,0x90
  629. FUNC_LABEL(log10)
  630. movl FUNC(mathLog10Func),%eax
  631. jmp *%eax /* jump, let that routine rts */
  633. /*******************************************************************************
  634. *
  635. * log2 - ANSI-compatable floating-point logarithm base 2 
  636. *
  637. * RETURNS: The logarithm (base 2) of dblParam.
  638. *
  639. * SEE ALSO: floatLib (1), log10 (2)
  641. * double log2 (dblParam)
  642. *     double dblParam; /* argument *
  644. */
  646. .balign 16,0x90
  647. FUNC_LABEL(log2)
  648. movl FUNC(mathLog2Func),%eax
  649. jmp *%eax /* jump, let that routine rts */
  651. /*******************************************************************************
  652. *
  653. * pow - ANSI-compatable floating-point dblX to the power of floating-point dblY 
  654. *
  655. * RETURNS: The floating-point value of dblX to the power of dblY.
  656. *
  657. * SEE ALSO: floatLib (1), sqrt (2)
  659. * double pow (dblX, dblY)
  660. *     double dblX; /* X *
  661. *     double dblY; /* X *
  663. */
  665. .balign 16,0x90
  666. FUNC_LABEL(pow)  /* pow (x,y) = exp (y * log(x)) */
  667. movl FUNC(mathPowFunc),%eax
  668. jmp *%eax /* jump, let that routine rts */
  670. /*******************************************************************************
  671. *
  672. * round - floating-point rounding
  673. *
  674. * Performs a 'round-to-nearest'.
  675. *
  676. * SEE ALSO: floatLib (1)
  678. * double round (dblParam)
  679. *     double dblParam; /* argument *
  681. */
  683. .balign 16,0x90
  684. FUNC_LABEL(round)
  685. movl FUNC(mathRoundFunc),%eax
  686. jmp *%eax /* jump, let that routine rts */
  688. /*******************************************************************************
  689. *
  690. * sin - ANSI-compatable floating-point sine
  691. *
  692. * RETURNS: The floating-point sine of dblParam.
  693. *
  694. * SEE ALSO: 
  695. *   floatLib (1), cos (2), tan (2), 
  696. *   "The C Programming Language - Second Edition"
  698. * double sin (dblParam)
  699. *     double dblParam; /* angle in radians *
  701. */
  703. .balign 16,0x90
  704. FUNC_LABEL(sin)
  705. movl FUNC(mathSinFunc),%eax
  706. jmp *%eax /* jump, let that routine rts */
  708. /*******************************************************************************
  709. *
  710. * sincos - simultaneous floating-point sine and cosine
  711. *
  712. * RETURNS:
  713. * The simultaeous floating point results of sine and cosine of the 
  714. * radian argument  The dblParam must be in range of -1.0 to +1.0.
  715. *
  716. *
  717. * SEE ALSO: floatLib (1), "i80387 Floating-Point User's Manual"
  719. * void sincos (dblParam, sinResult, cosResult)
  720. *     double dblParam; /* angle in radians *
  721. *     double *sinResult; /* sine result buffer *
  722. *     double *cosResult; /* cosine result buffer *
  724. */
  726. .balign 16,0x90
  727. FUNC_LABEL(sincos)
  728. movl FUNC(mathSincosFunc),%eax
  729. jmp *%eax /* jump, let that routine rts */
  731. /*******************************************************************************
  732. *
  733. * sqrt - ANSI-compatable floating-point square root
  734. *
  735. * RETURNS: The floating-point square root of dblParam.
  736. *
  737. * SEE ALSO: floatLib(1), pow (2)
  739. * double sqrt (dblParam)
  740. *     double dblParam; /* argument *
  742. */
  744. .balign 16,0x90
  745. FUNC_LABEL(sqrt)
  746. movl FUNC(mathSqrtFunc),%eax
  747. jmp *%eax /* jump, let that routine rts */
  749. /*******************************************************************************
  750. *
  751. * tan - ANSI-compatable floating-point tangent
  752. *
  753. * RETURNS: Floating-point tangent of dblParam.
  754. *
  755. * SEE ALSO: floatLib (1), cos (2), sin (2),
  756. * "The C Programming Language - Second Edition"
  758. * double tan (dblParam)
  759. *     double dblParam; /* angle in radians *
  761. */
  763. .balign 16,0x90
  764. FUNC_LABEL(tan)
  765. movl FUNC(mathTanFunc),%eax
  766. jmp *%eax /* jump, let that routine rts */
  768. /*******************************************************************************
  769. *
  770. * trunc - floating-point truncation
  771. *
  772. * Performs FINTRZ.
  773. *
  774. * RETURNS:
  775. * The integer portion of a double-precision number,
  776. * result is in double-precision.
  777. *
  778. * SEE ALSO: floatLib (1)
  780. * double trunc (dblParam)
  781. *     double dblParam; /* argument *
  783. */
  785. .balign 16,0x90
  786. FUNC_LABEL(trunc)
  787. movl FUNC(mathTruncFunc),%eax
  788. jmp *%eax /* jump, let that routine rts */
  790. /*******************************************************************************
  791. *
  792. * facos - single-precision floating-point arc-cosine
  793. *
  794. * RETURNS: The arc-cosine in the range -pi/2 to pi/2 radians.
  796. * float facos (fltParam)
  797. *     float fltParam; /* angle in radians *
  799. */
  801. .balign 16,0x90
  802. FUNC_LABEL(facos)
  803. movl FUNC(mathFacosFunc),%eax
  804. jmp *%eax /* jump, let that routine rts */
  806. /*******************************************************************************
  807. *
  808. * fasin - single-precision floating-point arc-sine
  809. *
  810. * RETURNS: The arc-sine in the range 0.0 to pi radians.
  811. * 
  812. * SEE ALSO: 
  813. * floatLib (1), "The C Programming Language - Second Edition"
  815. * float fasin (fltParam)
  816. *     float fltParam; /* angle in radians *
  818. */
  820. .balign 16,0x90
  821. FUNC_LABEL(fasin)
  822. movl FUNC(mathFasinFunc),%eax
  823. jmp *%eax /* jump, let that routine rts */
  825. /*******************************************************************************
  826. *
  827. * fatan - single-precision floating-point arc-tangent
  828. *
  829. * RETURNS: The arc-tangent of fltParam in the range -pi/2 to pi/2.
  830. *
  831. * SEE ALSO: floatLib (1), acos (2), asin (2)
  833. * float fatan (fltParam)
  834. *     float fltParam; /* angle in radians *
  836. */
  838. .balign 16,0x90
  839. FUNC_LABEL(fatan)
  840. movl FUNC(mathFatanFunc),%eax
  841. jmp *%eax /* jump, let that routine rts */
  843. /*******************************************************************************
  844. *
  845. * fatan2 - function returns the arc tangent of (fltY/fltX) 
  846. *
  847. * RETURNS:
  848. *    The arc-tangent of (fltY/fltX) in the range -pi to pi.
  849. *
  850. * SEE ALSO: 
  851. * floatLib (1), "The C Programming Language - Second Edition"
  853. * float fatan2 (fltY, fltX)
  854. *     float fltY; /* Y *
  855. *     float fltX; /* X *
  857. */
  859. .balign 16,0x90
  860. FUNC_LABEL(fatan2)
  861. movl FUNC(mathFatan2Func),%eax
  862. jmp *%eax /* jump, let that routine rts */
  864. /*******************************************************************************
  865. *
  866. * fcbrt - single-precision floating-point cube root
  867. *
  868. * This routine takes a single-precision floating point parameter
  869. * and returns the single-precision cube root.
  870. *
  871. * RETURNS: single-precision cube root
  873. * float fcbrt (fltParam)
  874. *     float fltParam;  /* argument *
  876. */
  878. .balign 16,0x90
  879. FUNC_LABEL(fcbrt)
  880. movl FUNC(mathFcbrtFunc),%eax
  881. jmp *%eax /* jump, let that routine rts */
  883. /*******************************************************************************
  884. *
  885. * fceil - single-precision floating-point ceiling
  886. *
  887. * Performs a 'round-to-positive-infinity'
  888. *
  889. * RETURNS: 
  890. * The least integral value greater than or equal to fltParam,
  891. * result is returned in single precision.
  892. *
  893. * SEE ALSO: 
  894. * floatLib (1), "The C Programming Language - Second Edition"
  896. * float fceil (fltParam)
  897. *     float fltParam; /* argument *
  899. */
  901. .balign 16,0x90
  902. FUNC_LABEL(fceil)
  903. movl FUNC(mathFceilFunc),%eax
  904. jmp *%eax /* jump, let that routine rts */
  906. /*******************************************************************************
  907. *
  908. * fcos - single-precision floating-point cosine
  909. *
  910. * RETURNS: the cosine of the radian argument fltParam
  911. *
  912. * SEE ALSO: 
  913. * floatLib (1), sin (2), cos (2), tan(2),
  914. * "The C Programming Language - Second Edition"
  916. * float fcos (fltParam)
  917. *     float fltParam; /* angle in radians *
  919. */
  921. .balign 16,0x90
  922. FUNC_LABEL(fcos)
  923. movl FUNC(mathFcosFunc),%eax
  924. jmp *%eax /* jump, let that routine rts */
  926. /*******************************************************************************
  927. *
  928. * fcosh - single-precision floating-point hyperbolic cosine
  929. *
  930. * RETURNS:
  931. *    The hyperbolic cosine of fltParam if (fltParam > 1.0), or
  932. *    NaN if (fltParam < 1.0) 
  933. *
  934. * SEE ALSO: "The C Programming Language - Second Edition"
  936. * float fcosh (fltParam)
  937. *     float fltParam; /* angle in radians *
  939. */
  941. .balign 16,0x90
  942. FUNC_LABEL(fcosh)
  943. movl FUNC(mathFcoshFunc),%eax
  944. jmp *%eax /* jump, let that routine rts */
  946. /*******************************************************************************
  947. *
  948. * fexp - single-precision exponential function
  949. *
  950. * RETURNS:
  951. *    Floating-point inverse natural logarithm (e ** (fltExponent)).
  952. *
  953. * SEE ALSO: 
  954. * floatLib (1), "The C Programming Language - Second Edition"
  956. * float fexp (fltExponent)
  957. *     float fltExponent; /* argument *
  959. */
  961. .balign 16,0x90
  962. FUNC_LABEL(fexp)
  963. movl FUNC(mathFexpFunc),%eax
  964. jmp *%eax /* jump, let that routine rts */
  966. /*******************************************************************************
  967. *
  968. * ffabs - single-precision floating-point absolute value
  969. *
  970. * RETURNS: The floating-point absolute value of fltParam.
  971. *
  972. * SEE ALSO: 
  973. * floatLib (1), "The C Programming Language - Second Edition"
  975. * float ffabs (fltParam)
  976. *     float fltParam; /* argument *
  978. */
  980. .balign 16,0x90
  981. FUNC_LABEL(ffabs)
  982. movl FUNC(mathFfabsFunc),%eax
  983. jmp *%eax /* jump, let that routine rts */
  985. /*******************************************************************************
  986. *
  987. * ffloor - single-precision floating-point floor
  988. *
  989. * Performs a 'round-to-negative-infinity'.
  990. *
  991. * RETURNS: 
  992. * The largest integral value less than or equal to fltParam,
  993. * result is returned in single precision.
  994. *
  995. * SEE ALSO: 
  996. * floatLib (1), "The C Programming Language - Second Edition"
  998. * float ffloor (fltParam)
  999. *     float fltParam; /* argument *
  1001. */
  1003. .balign 16,0x90
  1004. FUNC_LABEL(ffloor)
  1005. movl FUNC(mathFfloorFunc),%eax
  1006. jmp *%eax /* jump, let that routine rts */
  1008. /*******************************************************************************
  1009. *
  1010. * ffmod - single-precision floating-point modulus 
  1011. *
  1012. * RETURNS: 
  1013. * Floating-point modulus of (fltParam / fltDivisor) with the sign of fltParam.  
  1014. *
  1015. * SEE ALSO: 
  1016. * floatLib (1), "The C Programming Language - Second Edition"
  1018. * float ffmod (fltParam, fltDivisor)
  1019. *     float fltParam; /* argument *
  1020. *     float fltDivisor; /* divisor *
  1022. */
  1024. .balign 16,0x90
  1025. FUNC_LABEL(ffmod)
  1026. movl FUNC(mathFfmodFunc),%eax
  1027. jmp *%eax /* jump, let that routine rts */
  1029. /*******************************************************************************
  1030. *
  1031. * fhypot - single-precision Euclidean distance (hypotenuse)
  1032. *
  1033. * This routine takes two input single-precision floating point
  1034. * parameters and returns length of the corresponding Euclidean distance
  1035. * (hypotenuse).
  1036. *
  1037. * The distance is calculated as
  1038. * sqrt ((fltX * fltX) + (fltY * fltY))
  1039. *
  1040. * RETURNS: single-precision hypotenuse.
  1041. *
  1043. * float fhypot (fltX, fltY)
  1044. *     float fltX; /* argument *
  1045. *     float fltY; /* argument *
  1047. */
  1049. .balign 16,0x90
  1050. FUNC_LABEL(fhypot)
  1051. movl FUNC(mathFhypotFunc),%eax
  1052. jmp *%eax /* jump, let that routine rts */
  1054. /********************************************************************************
  1055. * finfinity - return a very large float
  1056. *
  1057. * SEE ALSO: floatLib(1)
  1059. * float finfinity ()
  1061. */
  1062.  
  1063. .balign 16,0x90
  1064. FUNC_LABEL(finfinity)
  1065. movl FUNC(mathFinfinityFunc),%eax
  1066. jmp *%eax /* jump, let that routine rts */
  1068. /********************************************************************************
  1069. * firint - convert float to integer
  1070. *
  1071. * Convert fltParam to an integer using the selected IEEE
  1072. * rounding direction.
  1073. *
  1074. * CAVEAT:
  1075. * The rounding direction is not pre-selectable
  1076. * and is fixed for 'round-to-the-nearest'.
  1077. *
  1078. * SEE ALSO: floatLib (1)
  1080. * int firint (fltParam)
  1081. *     float fltParam; /* argument *
  1083. */
  1084.  
  1085. .balign 16,0x90
  1086. FUNC_LABEL(firint)
  1087. movl FUNC(mathFirintFunc),%eax
  1088. jmp *%eax /* jump, let that routine rts */
  1090. /*******************************************************************************
  1091. *
  1092. * firound - INTEGER floating-point rounding
  1093. *
  1094. * Performs a 'round-to-the-nearest' function.
  1095. *
  1096. * NOTE:
  1097. * If fltParam is spaced evenly between two integers,
  1098. * then the  even integer will be returned.
  1100. * int firound (fltParam)
  1101. *     float fltParam; /* argument *
  1103. */
  1105. .balign 16,0x90
  1106. FUNC_LABEL(firound)
  1107. movl FUNC(mathFiroundFunc),%eax
  1108. jmp *%eax /* jump, let that routine rts */
  1110. /*******************************************************************************
  1111. *
  1112. * flog - single-precision floating-point natural logarithm 
  1113. *
  1114. * RETURNS: The natural logarithm of fltParam.
  1115. *
  1116. * SEE ALSO: 
  1117. * floatLib (1), "The C Programming Language - Second Edition"
  1119. * float flog (fltParam)
  1120. *     float fltParam; /* argument *
  1122. */
  1124. .balign 16,0x90
  1125. FUNC_LABEL(flog)
  1126. movl FUNC(mathFlogFunc),%eax
  1127. jmp *%eax /* jump, let that routine rts */
  1129. /*******************************************************************************
  1130. *
  1131. * flog10 - single-precision floating-point logarithm base 10 
  1132. *
  1133. * RETURNS: The logarithm (base 10) of fltParam.
  1134. *
  1135. * SEE ALSO: floatLib (1), log2 (2)
  1137. * float flog10 (fltParam)
  1138. *     float fltParam; /* argument *
  1140. */
  1142. .balign 16,0x90
  1143. FUNC_LABEL(flog10)
  1144. movl FUNC(mathFlog10Func),%eax
  1145. jmp *%eax /* jump, let that routine rts */
  1147. /*******************************************************************************
  1148. *
  1149. * flog2 - single-precision floating-point logarithm base 2 
  1150. *
  1151. * RETURNS: The logarithm (base 2) of fltParam.
  1152. *
  1153. * SEE ALSO: floatLib (1), log10 (2)
  1155. * float flog2 (fltParam)
  1156. *     float fltParam; /* argument *
  1158. */
  1160. .balign 16,0x90
  1161. FUNC_LABEL(flog2)
  1162. movl FUNC(mathFlog2Func),%eax
  1163. jmp *%eax /* jump, let that routine rts */
  1165. /*******************************************************************************
  1166. *
  1167. * fpow - single-precision floating point X to the power of floating-point Y 
  1168. *
  1169. * RETURNS: The floating-point value of fltX to the power of fltY.
  1170. *
  1171. * SEE ALSO: floatLib (1), sqrt (2)
  1173. * float fpow (fltX, fltY)
  1174. *     float fltX; /* X *
  1175. *     float fltY; /* X *
  1177. */
  1179. .balign 16,0x90
  1180. FUNC_LABEL(fpow)  /* pow (x,y) = exp (y * log(x)) */
  1181. movl FUNC(mathFpowFunc),%eax
  1182. jmp *%eax /* jump, let that routine rts */
  1184. /*******************************************************************************
  1185. *
  1186. * fround - floating-point rounding
  1187. *
  1188. * Performs a 'round-to-nearest'.
  1189. *
  1190. * SEE ALSO: floatLib (1)
  1192. * float fround (fltParam)
  1193. *     float fltParam; /* argument *
  1195. */
  1197. .balign 16,0x90
  1198. FUNC_LABEL(fround)
  1199. movl FUNC(mathFroundFunc),%eax
  1200. jmp *%eax /* jump, let that routine rts */
  1202. /*******************************************************************************
  1203. *
  1204. * fsin - single-precision floating-point sine
  1205. *
  1206. * RETURNS: The floating-point sine of fltParam.
  1207. *
  1208. * SEE ALSO: 
  1209. *   floatLib (1), cos (2), tan (2), 
  1210. *   "The C Programming Language - Second Edition"
  1212. * float fsin (fltParam)
  1213. *     float fltParam; /* angle in radians *
  1215. */
  1217. .balign 16,0x90
  1218. FUNC_LABEL(fsin)
  1219. movl FUNC(mathFsinFunc),%eax
  1220. jmp *%eax /* jump, let that routine rts */
  1222. /*******************************************************************************
  1223. *
  1224. * fsincos - simultaneous single-precision floating-point sine and cosine
  1225. *
  1226. * RETURNS:
  1227. * The simultaeous floating point results of sine and cosine of the 
  1228. * radian argument  The fltParam must be in range of -1.0 to +1.0.
  1229. *
  1230. *
  1231. * SEE ALSO: floatLib (1), "i80387 Floating-Point User's Manual"
  1233. * void fsincos (fltParam, sinResult, cosResult)
  1234. *     float fltParam; /* angle in radians *
  1235. *     float *sinResult; /* sine result buffer *
  1236. *     float *cosResult; /* cosine result buffer *
  1238. */
  1240. .balign 16,0x90
  1241. FUNC_LABEL(fsincos)
  1242. movl FUNC(mathFsincosFunc),%eax
  1243. jmp *%eax /* jump, let that routine rts */
  1245. /*******************************************************************************
  1246. *
  1247. * fsinh - single-precision floating-point hyperbolic sine
  1248. *
  1249. * RETURNS: The floating-point hyperbolic sine of fltParam.
  1250. *
  1251. * SEE ALSO: 
  1252. * floatLib (1), "The C Programming Language - Second Edition"
  1254. * float fsinh (fltParam)
  1255. *     float fltParam; /* angle in radians *
  1257. */
  1259. .balign 16,0x90
  1260. FUNC_LABEL(fsinh)
  1261. movl FUNC(mathFsinhFunc),%eax
  1262. jmp *%eax /* jump, let that routine rts */
  1264. /*******************************************************************************
  1265. *
  1266. * fsqrt - single-precision floating-point square root
  1267. *
  1268. * RETURNS: The floating-point square root of fltParam.
  1269. *
  1270. * SEE ALSO: floatLib(1), pow (2)
  1272. * float fsqrt (fltParam)
  1273. *     float fltParam; /* argument *
  1275. */
  1277. .balign 16,0x90
  1278. FUNC_LABEL(fsqrt)
  1279. movl FUNC(mathFsqrtFunc),%eax
  1280. jmp *%eax /* jump, let that routine rts */
  1282. /*******************************************************************************
  1283. *
  1284. * ftan - single-precision floating-point tangent
  1285. *
  1286. * RETURNS: Floating-point tangent of fltParam.
  1287. *
  1288. * SEE ALSO: floatLib (1), cos (2), sin (2),
  1289. * "The C Programming Language - Second Edition"
  1291. * float ftan (fltParam)
  1292. *     float fltParam; /* angle in radians *
  1294. */
  1296. .balign 16,0x90
  1297. FUNC_LABEL(ftan)
  1298. movl FUNC(mathFtanFunc),%eax
  1299. jmp *%eax /* jump, let that routine rts */
  1301. /*******************************************************************************
  1302. *
  1303. * ftanh - single-precision floating-point hyperbolic tangent
  1304. *
  1305. * RETURNS: Floating-point hyperbolic tangent of fltParam.
  1306. *
  1307. * SEE ALSO: 
  1308. * floatLib (1), fcosh (), fsinh ()
  1309. * "The C Programming Language - Second Edition"
  1311. * float ftanh (fltParam)
  1312. *     float fltParam; /* angle in radians *
  1314. */
  1316. .balign 16,0x90
  1317. FUNC_LABEL(ftanh)
  1318. movl FUNC(mathFtanhFunc),%eax
  1319. jmp *%eax /* jump, let that routine rts */
  1321. /*******************************************************************************
  1322. *
  1323. * ftrunc - single-precision floating-point truncation
  1324. *
  1325. * Performs FINTRZ.
  1326. *
  1327. * RETURNS:
  1328. * The integer portion of a single-precision number,
  1329. * result is in single-precision.
  1330. *
  1331. * SEE ALSO: floatLib (1)
  1333. * float ftrunc (fltParam)
  1334. *     float fltParam; /* argument *
  1336. */
  1338. .balign 16,0x90
  1339. FUNC_LABEL(ftrunc)
  1340. movl FUNC(mathFtruncFunc),%eax
  1341. jmp *%eax /* jump, let that routine rts */
  1343. /*******************************************************************************
  1344. *
  1345. * mathErrNoInit - default routine for uninitialized floating-point functions
  1346. *
  1347. * This routine is called if floating point math operations are attempted
  1348. * before either a mathSoftInit() or mathHardInit() call is performed.  The
  1349. * address of this routine is the initial value of the various mathXXXFunc
  1350. * pointers, which are re-initialized with actual function addresses during
  1351. * either of the floating point initialization calls.
  1352. *
  1353. * SEE ALSO: mathHardInit(), mathSoftInit()
  1355. * void mathErrNoInit ()
  1357. */
  1359. .balign 16,0x90
  1360. FUNC_LABEL(mathErrNoInit)
  1361. pushl $FUNC(mathErrNoInitString)
  1362. call FUNC(logMsg)
  1363. addl $4,%esp
  1364. ret