Subversion Repositories Kolibri OS

Rev

Rev 5235 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "rsmicrolibc.h"
  2.  
  3. // some math and string functions
  4.  
  5. double sqrt( double val ) {
  6.     double result ;
  7.     asm volatile ( "fld %1;"
  8.                             "fsqrt;"
  9.                             "fstp %0;" : "=g" (result) : "g" (val)
  10.     ) ;
  11.     return result;
  12. };
  13.  
  14. float sqrtf( float f ) {
  15.         return (float) sqrtf(f);
  16. };
  17.  
  18.  
  19. double sin(double val)
  20. {
  21.     double result ;
  22.     asm volatile ( "fld %1;"
  23.                             "fsin;"
  24.                             "fstp %0;" : "=g" (result) : "g" (val)
  25.     ) ;
  26.     return result;
  27. }
  28.  
  29. double cos(double val)
  30. {
  31.     double result ;
  32.     asm volatile ( "fld %1;"
  33.                             "fcos;"
  34.                             "fstp %0;" : "=g" (result) : "g" (val)
  35.     ) ;
  36.     return result;
  37. }
  38.  
  39.  
  40. double exp (double x)
  41. {
  42.    double result;
  43.    asm ("fldl2e; "
  44.                  "fmulp; "
  45.                  "fld %%st; "
  46.                  "frndint; "
  47.                  "fsub %%st,%%st(1); "
  48.                  "fxch;"
  49.                  "fchs; "
  50.                  "f2xm1; "
  51.                  "fld1; "
  52.                  "faddp; "
  53.                  "fxch; "
  54.                  "fld1; "
  55.                  "fscale; "
  56.                  "fstp %%st(1); "
  57.                  "fmulp" :  "=t"(result) : "0"(x));
  58.    return result;
  59. }
  60.  
  61. float expf(float x) {
  62.         return (float)(exp(x));
  63. };
  64.  
  65.  
  66.  
  67.  
  68. double log(double Power)
  69. {
  70.    
  71.         // From here:  http://www.codeproject.com/Tips/311714/Natural-Logarithms-and-Exponent
  72.    
  73.         double N, P, L, R, A, E;
  74.         E = 2.71828182845905;
  75.         P = Power;
  76.         N = 0.0;
  77.  
  78.             // This speeds up the convergence by calculating the integral
  79.         while(P >= E)  
  80.         {
  81.                 P /= E;
  82.                 N++;
  83.         }
  84.             N += (P / E);
  85.         P = Power;
  86.        
  87.         do
  88.         {
  89.                 A = N;
  90.                 L = (P / (exp(N - 1.0)));
  91.                 R = ((N - 1.0) * E);
  92.                 N = ((L + R) / E);
  93.         } while (!( fabs(N-A)<0.01 ));
  94.        
  95.         return N;
  96. }
  97.    
  98.  
  99. float logf(float x) {
  100.         return (float)(log(x));
  101. };
  102.  
  103. double pow(double x, double p) {
  104.    
  105.     if (x < 0.001) {
  106.         return 0.0;
  107.     };
  108.    
  109.         return exp(p * log(x));
  110. };
  111. float powf(float x, float p) {
  112.         return expf(p * logf(x));
  113. };
  114.  
  115.  
  116.  
  117.  
  118. int abs(int x) {
  119.         return (x>0) ? x : -x;
  120. };
  121. double fabs(double x) {
  122.         return (x>0) ? x : -x;
  123. };
  124.  
  125. double floor(double x) {
  126.         return (double)((int)x); // <--------- only positive!
  127. };
  128.  
  129. double round(double x) {
  130.         return floor(x+0.5);
  131. };
  132. float roundf(float x) {
  133.         return (float)round(x);
  134. };
  135.  
  136.  
  137.  
  138.  
  139. void* malloc(unsigned s)
  140. {
  141.         asm ("int $0x40"::"a"(68), "b"(12), "c"(s) );
  142. }
  143.  
  144.  
  145. void free(void *p)
  146. {
  147.         asm ("int $0x40"::"a"(68), "b"(13), "c"(p) );
  148. }
  149.  
  150. void*  memset(void *mem, int c, unsigned size)
  151. {
  152.         unsigned i;
  153.  
  154.         for ( i = 0; i < size; i++ )
  155.                  *((char *)mem+i) = (char) c;
  156.  
  157.         return NULL;   
  158. }
  159.  
  160.  
  161. void* memcpy(void *dst, const void *src, unsigned size)
  162. {
  163.  
  164.         unsigned i;
  165.  
  166.         for ( i = 0; i < size; i++)
  167.                 *(char *)(dst+i) = *(char *)(src+i);
  168.  
  169.         return NULL;
  170. }
  171.  
  172.  
  173. char*  strchr(char* s, int c) {
  174.  
  175.         while (*s) {
  176.                 if (*s == (char) c) {
  177.                         return s;
  178.                 };
  179.                 s++;
  180.         };
  181.         return NULL;
  182.  
  183. };
  184.  
  185. unsigned int strlen ( char * str ) {
  186.         unsigned int len = 0;
  187.         while ( *str ) {
  188.                 len++;
  189.                 str++;
  190.         };
  191.         return len;
  192. };
  193.  
  194.