     CCS PCM C Compiler, Version 4.106, 47914               15-V-13 18:53
     CCS PCM C Compiler, Version 4.106, 47914               15-V-13 20:34
                    Filename: Z:\home\kaklik\svnMLAB\Modules\Sensors\MAG01A\SW\PIC16F887\main.lst
                    ROM used: 821 words (10%)
                    ROM used: 775 words (9%)
                              Largest free fragment is 2048
                    RAM used: 18 (5%) at main() level
 (7%) worst case
                    RAM used: 28 (8%) at main() level
 (10%) worst case
                    Stack:    2 locations
+    *
 :  MOVLW  02
 :  MOVWF  0A
 :  GOTO   250
 :  GOTO   24F
 :  NOP
     .................... #include "main.h"
     .................... #include <16F887.h>
-...
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  RLF    32,F
 :  RLF    3D,F
 A:  BCF    07.4
 B:  BTFSS  03.0
 C:  GOTO   033
-...
 :  BCF    03.5
 :  RETURN
+    *
 C:  MOVLW  08
 D:  MOVWF  33
 E:  MOVF   77,W
 F:  MOVWF  34
 :  BSF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BSF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 A:  BCF    03.5
 B:  BTFSS  07.3
 C:  GOTO   11B
 D:  BTFSC  07.4
 E:  BSF    03.0
 F:  BTFSS  07.4
 :  BCF    03.0
 :  RLF    78,F
 :  NOP
 :  BCF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  BCF    03.5
 :  BCF    07.3
 :  DECFSZ 33,F
 A:  GOTO   110
 B:  BSF    20.4
 C:  MOVF   20,W
 D:  BSF    03.5
 E:  MOVWF  07
 F:  NOP
 :  BCF    03.5
 :  BCF    07.4
 :  MOVF   34,W
 :  BTFSC  03.2
 :  GOTO   13A
 :  BCF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  BCF    03.5
 A:  NOP
 B:  BSF    20.3
 C:  MOVF   20,W
 D:  BSF    03.5
 E:  MOVWF  07
 F:  BCF    03.5
 :  BTFSS  07.3
 :  GOTO   140
 :  NOP
 :  BCF    07.3
 :  BCF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 A:  BCF    07.4
 B:  BCF    20.4
 C:  MOVF   20,W
 D:  BSF    03.5
 E:  MOVWF  07
 F:  BCF    03.5
 :  RETURN
     .................... #use rs232(baud=9600,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD
 B:  MOVLW  08
 C:  MOVWF  3E
 D:  MOVF   77,W
 E:  MOVWF  3F
 F:  BSF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BSF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  BCF    03.5
 A:  BTFSS  07.3
 B:  GOTO   11A
 C:  BTFSC  07.4
 D:  BSF    03.0
 E:  BTFSS  07.4
 F:  BCF    03.0
 :  RLF    78,F
 :  NOP
 :  BCF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  BCF    03.5
 :  BCF    07.3
 :  DECFSZ 3E,F
 :  GOTO   10F
 A:  BSF    20.4
 B:  MOVF   20,W
 C:  BSF    03.5
 D:  MOVWF  07
 E:  NOP
 F:  BCF    03.5
 :  BCF    07.4
 :  MOVF   3F,W
 :  BTFSC  03.2
 :  GOTO   139
 :  BCF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  BCF    03.5
 :  NOP
 A:  BSF    20.3
 B:  MOVF   20,W
 C:  BSF    03.5
 D:  MOVWF  07
 E:  BCF    03.5
 F:  BTFSS  07.3
 :  GOTO   13F
 :  NOP
 :  BCF    07.3
 :  BCF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BCF    07.4
 A:  BCF    20.4
 B:  MOVF   20,W
 C:  BSF    03.5
 D:  MOVWF  07
 E:  BCF    03.5
 F:  RETURN
     .................... #use rs232(baud=115200,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD
+    *
 A2:  BCF    20.7
 A3:  MOVF   20,W
-...
 AA:  GOTO   0AB
 AB:  NOP
 AC:  BSF    78.7
 AD:  GOTO   0BC
 AD:  GOTO   0C0
 AE:  BCF    78.7
 AF:  RRF    35,F
 B0:  BTFSC  03.0
 B1:  BSF    07.7
 B2:  BTFSS  03.0
 B3:  BCF    07.7
 B4:  BSF    78.6
 B5:  GOTO   0BC
 B6:  BCF    78.6
 B7:  DECFSZ 78,F
 B8:  GOTO   0AF
 B9:  GOTO   0BA
 BA:  NOP
 BB:  BSF    07.7
 BC:  MOVLW  3F
 BD:  MOVWF  04
 BE:  DECFSZ 04,F
 BF:  GOTO   0BE
 C0:  NOP
 C1:  BTFSC  78.7
 C2:  GOTO   0AE
 C3:  BTFSC  78.6
 C4:  GOTO   0B6
 C5:  RETURN
 AF:  MOVF   40,W
 B0:  MOVWF  79
 B1:  RRF    79,F
 B2:  BTFSC  03.0
 B3:  BSF    07.7
 B4:  BTFSS  03.0
 B5:  BCF    07.7
 B6:  BSF    78.6
 B7:  GOTO   0C0
 B8:  BCF    78.6
 B9:  DECFSZ 78,F
 BA:  GOTO   0B1
 BB:  MOVF   79,W
 BC:  MOVWF  40
 BD:  GOTO   0BE
 BE:  NOP
 BF:  BSF    07.7
 C0:  BTFSC  78.7
 C1:  GOTO   0AE
 C2:  BTFSC  78.6
 C3:  GOTO   0B8
 C4:  RETURN
     ....................
     ....................
     .................... #include "HMC5883L.h"
-...
     .................... i2c_write(HMC5883L_WRT_ADDR);
 :  MOVLW  3C
 :  BCF    03.5
 :  MOVWF  32
 :  MOVWF  3D
 :  CALL   01F
     .................... i2c_write(reg);
 :  MOVF   2C,W
 :  MOVWF  32
 :  MOVF   37,W
 :  MOVWF  3D
 :  CALL   01F
     .................... i2c_write(data);
 :  MOVF   2D,W
 :  MOVWF  32
 :  MOVF   38,W
 :  MOVWF  3D
 A:  CALL   01F
     .................... i2c_stop();
 B:  BCF    20.4
-...
     .................... // from the HMC5883L x,y,z registers.
     .................... hmc5883l_result compass = {0,0,0};
+    *
 :  CLRF   21
 :  CLRF   22
 :  CLRF   23
 :  CLRF   24
 :  CLRF   25
 :  CLRF   26
 :  CLRF   21
 :  CLRF   22
 :  CLRF   23
 :  CLRF   24
 :  CLRF   25
 :  CLRF   26
     ....................
     .................... //------------------------------
     .................... void hmc5883l_read_data(void)
-...
     ....................
     .................... i2c_start();
+    *
 :  BSF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BSF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 A:  MOVWF  07
 B:  NOP
 C:  BCF    03.5
 D:  BCF    07.4
 E:  BCF    20.4
 F:  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BCF    07.3
 :  BCF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  BSF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BSF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 A:  NOP
 B:  BCF    03.5
 C:  BCF    07.4
 D:  BCF    20.4
 E:  MOVF   20,W
 F:  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BCF    07.3
 :  BCF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
     .................... i2c_write(HMC5883L_WRT_ADDR);
 :  MOVLW  3C
 A:  BCF    03.5
 B:  MOVWF  32
 C:  CALL   01F
 :  MOVLW  3C
 :  BCF    03.5
 A:  MOVWF  3D
 B:  CALL   01F
     .................... i2c_write(HMC5883L_X_MSB_REG);  // Point to X-msb register
 D:  MOVLW  03
 E:  MOVWF  32
 F:  CALL   01F
 C:  MOVLW  03
 D:  MOVWF  3D
 E:  CALL   01F
     .................... i2c_start();
 :  BSF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BSF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 A:  NOP
 B:  BCF    03.5
 C:  BTFSS  07.3
 D:  GOTO   17C
 E:  BCF    07.4
 F:  BCF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BCF    07.3
 :  BCF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 F:  BSF    20.4
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BSF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 A:  BCF    03.5
 B:  BTFSS  07.3
 C:  GOTO   17B
 D:  BCF    07.4
 E:  BCF    20.4
 F:  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
 :  NOP
 :  BCF    03.5
 :  BCF    07.3
 :  BCF    20.3
 :  MOVF   20,W
 :  BSF    03.5
 :  MOVWF  07
     .................... i2c_write(HMC5883L_READ_ADDR);
 A:  MOVLW  3D
 B:  BCF    03.5
 C:  MOVWF  32
 D:  CALL   01F
 :  MOVLW  3D
 A:  BCF    03.5
 B:  MOVWF  3D
 C:  CALL   01F
     ....................
     .................... x_msb = i2c_read();
 E:  MOVLW  01
 F:  MOVWF  77
 :  CALL   10C
 :  MOVF   78,W
 :  MOVWF  2D
 D:  MOVLW  01
 E:  MOVWF  77
 F:  CALL   10B
 :  MOVF   78,W
 :  MOVWF  38
     .................... x_lsb = i2c_read();
 :  MOVLW  01
 :  MOVWF  77
 :  CALL   10C
 :  MOVF   78,W
 :  MOVWF  2C
 :  MOVLW  01
 :  MOVWF  77
 :  CALL   10B
 :  MOVF   78,W
 :  MOVWF  37
     ....................
     .................... z_msb = i2c_read();
 :  MOVLW  01
 :  MOVWF  77
 A:  CALL   10C
 B:  MOVF   78,W
 C:  MOVWF  31
 :  MOVLW  01
 :  MOVWF  77
 :  CALL   10B
 A:  MOVF   78,W
 B:  MOVWF  3C
     .................... z_lsb = i2c_read();
 D:  MOVLW  01
 E:  MOVWF  77
 F:  CALL   10C
 A0:  MOVF   78,W
 A1:  MOVWF  30
 C:  MOVLW  01
 D:  MOVWF  77
 E:  CALL   10B
 F:  MOVF   78,W
 A0:  MOVWF  3B
     ....................
     .................... y_msb = i2c_read();
 A2:  MOVLW  01
 A3:  MOVWF  77
 A4:  CALL   10C
 A5:  MOVF   78,W
 A6:  MOVWF  2F
 A1:  MOVLW  01
 A2:  MOVWF  77
 A3:  CALL   10B
 A4:  MOVF   78,W
 A5:  MOVWF  3A
     .................... y_lsb = i2c_read(0); // do a NACK on last read
 A7:  CLRF   77
 A8:  CALL   10C
 A9:  MOVF   78,W
 AA:  MOVWF  2E
 A6:  CLRF   77
 A7:  CALL   10B
 A8:  MOVF   78,W
 A9:  MOVWF  39
     ....................
     .................... i2c_stop();
 AB:  BCF    20.4
 AC:  MOVF   20,W
 AD:  BSF    03.5
 AE:  MOVWF  07
 AF:  NOP
 B0:  BCF    03.5
 B1:  BSF    20.3
 B2:  MOVF   20,W
 B3:  BSF    03.5
 B4:  MOVWF  07
 B5:  BCF    03.5
 B6:  BTFSS  07.3
 B7:  GOTO   1B6
 B8:  NOP
 B9:  GOTO   1BA
 BA:  NOP
 BB:  BSF    20.4
 BC:  MOVF   20,W
 BD:  BSF    03.5
 BE:  MOVWF  07
 BF:  NOP
 AA:  BCF    20.4
 AB:  MOVF   20,W
 AC:  BSF    03.5
 AD:  MOVWF  07
 AE:  NOP
 AF:  BCF    03.5
 B0:  BSF    20.3
 B1:  MOVF   20,W
 B2:  BSF    03.5
 B3:  MOVWF  07
 B4:  BCF    03.5
 B5:  BTFSS  07.3
 B6:  GOTO   1B5
 B7:  NOP
 B8:  GOTO   1B9
 B9:  NOP
 BA:  BSF    20.4
 BB:  MOVF   20,W
 BC:  BSF    03.5
 BD:  MOVWF  07
 BE:  NOP
     ....................
     .................... // Combine high and low bytes into 16-bit values.
     .................... compass.x = make16(x_msb, x_lsb);
 C0:  BCF    03.5
 C1:  MOVF   2D,W
 C2:  MOVWF  22
 C3:  MOVF   2C,W
 C4:  MOVWF  21
 BF:  BCF    03.5
 C0:  MOVF   38,W
 C1:  MOVWF  22
 C2:  MOVF   37,W
 C3:  MOVWF  21
     .................... compass.y = make16(y_msb, y_lsb);
 C5:  MOVF   2F,W
 C6:  MOVWF  24
 C7:  MOVF   2E,W
 C8:  MOVWF  23
 C4:  MOVF   3A,W
 C5:  MOVWF  24
 C6:  MOVF   39,W
 C7:  MOVWF  23
     .................... compass.z = make16(z_msb, z_lsb);
 C9:  MOVF   31,W
 CA:  MOVWF  26
 CB:  MOVF   30,W
 CC:  MOVWF  25
 C8:  MOVF   3C,W
 C9:  MOVWF  26
 CA:  MOVF   3B,W
 CB:  MOVWF  25
     .................... }
 CD:  BCF    0A.3
 CE:  BCF    0A.4
 CF:  GOTO   2EE (RETURN)
 CC:  BCF    0A.3
 CD:  BCF    0A.4
 CE:  GOTO   2E1 (RETURN)
     ....................
     ....................
     ....................
     ....................
     .................... #include <math.h>
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... ////        (C) Copyright 1996,2008 Custom Computer Services            ////
     .................... //// This source code may only be used by licensed users of the CCS C   ////
     .................... //// compiler.  This source code may only be distributed to other       ////
     .................... //// licensed users of the CCS C compiler.  No other use, reproduction  ////
     .................... //// or distribution is permitted without written permission.           ////
     .................... //// Derivative programs created using this software in object code     ////
     .................... //// form are not restricted in any way.                                ////
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... ////                                                                    ////
     .................... //// History:                                                           ////
     .................... ////  * 9/20/2001 :  Improvments are made to sin/cos code.              ////
     .................... ////                 The code now is small, much faster,                ////
     .................... ////                 and more accurate.                                 ////
     .................... ////  * 2/21/2007 :  Compiler handles & operator differently and does
     .................... ////                 not return generic (int8 *) so type cast is done   ////
     .................... ////                                                                    ////
     .................... ////////////////////////////////////////////////////////////////////////////
     ....................
     .................... #ifndef MATH_H
     .................... #define MATH_H
     ....................
     .................... #ifdef PI
     .................... #undef  PI
     .................... #endif
     .................... #define PI     3.1415926535897932
     ....................
     ....................
     .................... #define SQRT2  1.4142135623730950
     ....................
     .................... //float const ps[4] = {5.9304945, 21.125224, 8.9403076, 0.29730279};
     .................... //float const qs[4] = {1.0000000, 15.035723, 17.764134, 2.4934718};
     ....................
     .................... ///////////////////////////// Round Functions //////////////////////////////
     ....................
     .................... float32 CEIL_FLOOR(float32 x, unsigned int8 n)
     .................... {
     ....................    float32 y, res;
     ....................    unsigned int16 l;
     ....................    int1 s;
     ....................
     ....................    s = 0;
     ....................    y = x;
     ....................
     ....................    if (x < 0)
     ....................    {
     ....................       s = 1;
     ....................       y = -y;
     ....................    }
     ....................
     ....................    if (y <= 32768.0)
     ....................   res = (float32)(unsigned int16)y;
     ....................
     ....................  else if (y < 10000000.0)
     ....................    {
     ....................   l = (unsigned int16)(y/32768.0);
     ....................       y = 32768.0*(y/32768.0 - (float32)l);
     ....................   res = 32768.0*(float32)l;
     ....................   res += (float32)(unsigned int16)y;
     ....................  }
     ....................
     ....................  else
     ....................   res = y;
     ....................
     ....................  y = y - (float32)(unsigned int16)y;
     ....................
     ....................  if (s)
     ....................   res = -res;
     ....................
     ....................  if (y != 0)
     ....................  {
     ....................   if (s == 1 && n == 0)
     ....................    res -= 1.0;
     ....................
     ....................   if (s == 0 && n == 1)
     ....................    res += 1.0;
     ....................  }
     ....................  if (x == 0)
     ....................     res = 0;
     ....................
     ....................  return (res);
     .................... }
     ....................
     .................... // Overloaded Functions to take care for new Data types in PCD
     .................... // Overloaded function CEIL_FLOOR() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 CEIL_FLOOR(float48 x, unsigned int8 n)
     .................... {
     ....................    float48 y, res;
     ....................    unsigned int16 l;
     ....................    int1 s;
     ....................
     ....................    s = 0;
     ....................    y = x;
     ....................
     ....................    if (x < 0)
     ....................    {
     ....................       s = 1;
     ....................       y = -y;
     ....................    }
     ....................
     ....................    if (y <= 32768.0)
     ....................   res = (float48)(unsigned int16)y;
     ....................
     ....................  else if (y < 10000000.0)
     ....................    {
     ....................   l = (unsigned int16)(y/32768.0);
     ....................       y = 32768.0*(y/32768.0 - (float48)l);
     ....................   res = 32768.0*(float32)l;
     ....................   res += (float48)(unsigned int16)y;
     ....................  }
     ....................
     ....................  else
     ....................   res = y;
     ....................
     ....................  y = y - (float48)(unsigned int16)y;
     ....................
     ....................  if (s)
     ....................   res = -res;
     ....................
     ....................  if (y != 0)
     ....................  {
     ....................   if (s == 1 && n == 0)
     ....................    res -= 1.0;
     ....................
     ....................   if (s == 0 && n == 1)
     ....................    res += 1.0;
     ....................  }
     ....................  if (x == 0)
     ....................     res = 0;
     ....................
     ....................  return (res);
     .................... }
     ....................
     ....................
     .................... // Overloaded function CEIL_FLOOR() for data type - Float64
     .................... float64 CEIL_FLOOR(float64 x, unsigned int8 n)
     .................... {
     ....................    float64 y, res;
     ....................    unsigned int16 l;
     ....................    int1 s;
     ....................
     ....................    s = 0;
     ....................    y = x;
     ....................
     ....................    if (x < 0)
     ....................    {
     ....................       s = 1;
     ....................       y = -y;
     ....................    }
     ....................
     ....................    if (y <= 32768.0)
     ....................   res = (float64)(unsigned int16)y;
     ....................
     ....................  else if (y < 10000000.0)
     ....................    {
     ....................   l = (unsigned int16)(y/32768.0);
     ....................       y = 32768.0*(y/32768.0 - (float64)l);
     ....................   res = 32768.0*(float64)l;
     ....................   res += (float64)(unsigned int16)y;
     ....................  }
     ....................
     ....................  else
     ....................   res = y;
     ....................
     ....................  y = y - (float64)(unsigned int16)y;
     ....................
     ....................  if (s)
     ....................   res = -res;
     ....................
     ....................  if (y != 0)
     ....................  {
     ....................   if (s == 1 && n == 0)
     ....................    res -= 1.0;
     ....................
     ....................   if (s == 0 && n == 1)
     ....................    res += 1.0;
     ....................  }
     ....................  if (x == 0)
     ....................     res = 0;
     ....................
     ....................  return (res);
     .................... }
     .................... #endif
     ....................
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float floor(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : rounds down the number x.
     .................... // Date : N/A
     .................... //
     .................... float32 floor(float32 x)
     .................... {
     ....................    return CEIL_FLOOR(x, 0);
     .................... }
     .................... // Following 2 functions are overloaded functions of floor() for PCD
     .................... // Overloaded function floor() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 floor(float48 x)
     .................... {
     ....................    return CEIL_FLOOR(x, 0);
     .................... }
     ....................
     .................... // Overloaded function floor() for data type - Float64
     .................... float64 floor(float64 x)
     .................... {
     ....................    return CEIL_FLOOR(x, 0);
     .................... }
     .................... #endif
     ....................
     ....................
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float ceil(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : rounds up the number x.
     .................... // Date : N/A
     .................... //
     .................... float32 ceil(float32 x)
     .................... {
     ....................    return CEIL_FLOOR(x, 1);
     .................... }
     .................... // Following 2 functions are overloaded functions of ceil() for PCD
     .................... // Overloaded function ceil() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 ceil(float48 x)
     .................... {
     ....................    return CEIL_FLOOR(x, 1);
     .................... }
     ....................
     .................... // Overloaded function ceil() for data type - Float64
     .................... float64 ceil(float64 x)
     .................... {
     ....................    return CEIL_FLOOR(x, 1);
     .................... }
     .................... #endif
     ....................
     ....................  ////////////////////////////////////////////////////////////////////////////
     .................... //   float fabs(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : Computes the absolute value of floating point number x
     .................... // Returns : returns the absolute value of x
     .................... // Date : N/A
     .................... //
     .................... #define fabs abs
     ....................
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float fmod(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : Computes the floating point remainder of x/y
     .................... // Returns : returns the value of x= i*y, for some integer i such that, if y
     .................... // is non zero, the result has the same isgn of x na dmagnitude less than the
     .................... // magnitude of y. If y is zero then a domain error occurs.
     .................... // Date : N/A
     .................... //
     ....................
     .................... float fmod(float32 x,float32 y)
     .................... {
     ....................    float32 i;
     ....................    if (y!=0.0)
     ....................    {
     ....................       i=(x/y < 0.0)? ceil(x/y): floor(x/y);
     ....................       return(x-(i*y));
     ....................    }
     ....................    else
     ....................    {
     ....................    #ifdef _ERRNO
     ....................    {
     ....................       errno=EDOM;
     ....................    }
     ....................    #endif
     ....................    }
     .................... }
     .................... //Overloaded function for fmod() for PCD
     .................... // Overloaded function fmod() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 fmod(float48 x,float48 y)
     .................... {
     ....................    float48 i;
     ....................    if (y!=0.0)
     ....................    {
     ....................       i=(x/y < 0.0)? ceil(x/y): floor(x/y);
     ....................       return(x-(i*y));
     ....................    }
     ....................    else
     ....................    {
     ....................    #ifdef _ERRNO
     ....................    {
     ....................       errno=EDOM;
     ....................    }
     ....................    #endif
     ....................    }
     .................... }
     .................... // Overloaded function fmod() for data type - Float64
     .................... float64 fmod(float64 x,float64 y)
     .................... {
     ....................    float64 i;
     ....................    if (y!=0.0)
     ....................    {
     ....................       i=(x/y < 0.0)? ceil(x/y): floor(x/y);
     ....................       return(x-(i*y));
     ....................    }
     ....................    else
     ....................    {
     ....................    #ifdef _ERRNO
     ....................    {
     ....................       errno=EDOM;
     ....................    }
     ....................    #endif
     ....................    }
     .................... }
     .................... #endif
     .................... //////////////////// Exponential and logarithmic functions ////////////////////
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float exp(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : returns the value (e^x)
     .................... // Date : N/A
     .................... //
     .................... #define LN2 0.6931471805599453
     ....................
     .................... float const pe[6] = {0.000207455774, 0.00127100575, 0.00965065093,
     ....................                      0.0554965651,  0.240227138,  0.693147172};
     ....................
     ....................
     .................... float32 exp(float32 x)
     .................... {
     ....................    float32 y, res, r;
     ....................    #if defined(__PCD__)
     ....................    int8 data1;
     ....................    #endif
     ....................    signed int8 n;
     ....................    int1 s;
     ....................    #ifdef _ERRNO
     ....................    if(x > 88.722838)
     ....................    {
     ....................       errno=ERANGE;
     ....................       return(0);
     ....................    }
     ....................    #endif
     ....................    n = (signed int16)(x/LN2);
     ....................    s = 0;
     ....................    y = x;
     ....................
     ....................    if (x < 0)
     ....................    {
     ....................       s = 1;
     ....................       n = -n;
     ....................       y = -y;
     ....................    }
     ....................
     ....................    res = 0.0;
     .................... #if !defined(__PCD__)
     ....................    *((unsigned int8 *)(&res)) = n + 0x7F;
     .................... #endif
     ....................
     .................... #if defined(__PCD__)  // Takes care of IEEE format for PCD
     ....................    data1 = n+0x7F;
     ....................    if(bit_test(data1,0))
     ....................    bit_set(*(((unsigned int8 *)(&res)+2)),7);
     ....................    rotate_right(&data1,1);
     ....................    bit_clear(data1,7);
     ....................    *(((unsigned int8 *)(&res)+3)) = data1;
     .................... #endif
     ....................
     ....................    y = y/LN2 - (float32)n;
     ....................
     ....................    r = pe[0]*y + pe[1];
     ....................    r = r*y + pe[2];
     ....................    r = r*y + pe[3];
     ....................    r = r*y + pe[4];
     ....................    r = r*y + pe[5];
     ....................
     ....................    res = res*(1.0 + y*r);
     ....................
     ....................    if (s)
     ....................       res = 1.0/res;
     ....................    return(res);
     .................... }
     ....................
     ....................
     .................... //Overloaded function for exp() for PCD
     .................... // Overloaded function exp() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 exp(float48 x)
     .................... {
     ....................    float48 y, res, r;
     ....................    int8 data1;
     ....................    signed int8 n;
     ....................    int1 s;
     ....................    #ifdef _ERRNO
     ....................    if(x > 88.722838)
     ....................    {
     ....................       errno=ERANGE;
     ....................       return(0);
     ....................    }
     ....................    #endif
     ....................    n = (signed int16)(x/LN2);
     ....................    s = 0;
     ....................    y = x;
     ....................
     ....................    if (x < 0)
     ....................    {
     ....................       s = 1;
     ....................       n = -n;
     ....................       y = -y;
     ....................    }
     ....................
     ....................    res = 0.0;
     ....................
     ....................    data1 = n+0x7F;
     ....................    if(bit_test(data1,0))
     ....................    bit_set(*(((unsigned int8 *)(&res)+4)),7);
     ....................    rotate_right(&data1,1);
     ....................    bit_clear(data1,7);
     ....................    *(((unsigned int8 *)(&res)+5)) = data1;
     ....................
     ....................    y = y/LN2 - (float48)n;
     ....................
     ....................    r = pe[0]*y + pe[1];
     ....................    r = r*y + pe[2];
     ....................    r = r*y + pe[3];
     ....................    r = r*y + pe[4];
     ....................    r = r*y + pe[5];
     ....................
     ....................    res = res*(1.0 + y*r);
     ....................
     ....................    if (s)
     ....................       res = 1.0/res;
     ....................    return(res);
     .................... }
     ....................
     .................... // Overloaded function exp() for data type - Float64
     .................... float64 exp(float64 x)
     .................... {
     ....................    float64 y, res, r;
     ....................    unsigned int16 data1, data2;
     ....................    unsigned int16 *p;
     ....................    signed int16 n;
     ....................    int1 s;
     ....................    #ifdef _ERRNO
     ....................    if(x > 709.7827128)
     ....................    {
     ....................       errno=ERANGE;
     ....................       return(0);
     ....................    }
     ....................    #endif
     ....................    n = (signed int16)(x/LN2);
     ....................    s = 0;
     ....................    y = x;
     ....................
     ....................    if (x < 0)
     ....................    {
     ....................       s = 1;
     ....................       n = -n;
     ....................       y = -y;
     ....................    }
     ....................
     ....................    res = 0.0;
     ....................
     .................... #if !defined(__PCD__)
     ....................    *((unsigned int16 *)(&res)) = n + 0x7F;
     .................... #endif
     ....................    p= (((unsigned int16 *)(&res))+3);
     ....................    data1 = *p;
     ....................    data2 = *p;
     ....................    data1 = n + 0x3FF;
     ....................    data1 = data1 <<4;
     ....................    if(bit_test(data2,15))
     ....................    bit_set(data1,15);
     ....................    data2 = data2 & 0x000F;
     ....................    data1 ^= data2;
     ....................
     ....................    *(((unsigned int16 *)(&res)+3)) = data1;
     ....................
     ....................
     ....................    y = y/LN2 - (float64)n;
     ....................
     ....................    r = pe[0]*y + pe[1];
     ....................    r = r*y + pe[2];
     ....................    r = r*y + pe[3];
     ....................    r = r*y + pe[4];
     ....................    r = r*y + pe[5];
     ....................
     ....................    res = res*(1.0 + y*r);
     ....................
     ....................    if (s)
     ....................       res = 1.0/res;
     ....................    return(res);
     .................... }
     ....................
     .................... #ENDIF
     ....................
     ....................
     .................... /************************************************************/
     ....................
     .................... float32 const pl[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};
     .................... float32 const ql[4] = {1.0000000,  -8.1354259, 16.780517, -9.9300943};
     ....................
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float log(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : returns the the natural log of x
     .................... // Date : N/A
     .................... //
     .................... float32 log(float32 x)
     .................... {
     ....................    float32 y, res, r, y2;
     ....................    #if defined(__PCD__)
     ....................    unsigned int8  data1,data2;
     ....................    #endif
     ....................    signed int8 n;
     ....................    #ifdef _ERRNO
     ....................    if(x <0)
     ....................    {
     ....................       errno=EDOM;
     ....................    }
     ....................    if(x ==0)
     ....................    {
     ....................       errno=ERANGE;
     ....................       return(0);
     ....................    }
     ....................    #endif
     ....................    y = x;
     ....................
     ....................    if (y != 1.0)
     ....................    {
     .................... #if !defined(__PCD__)
     ....................     *((unsigned int8 *)(&y)) = 0x7E;
     .................... #endif
     ....................
     .................... #if defined(__PCD__) // Takes care of IEEE format
     ....................    data2 = *(((unsigned int8 *)(&y))+3);
     ....................    *(((unsigned int8 *)(&y))+3) = 0x3F;
     ....................    data1 = *(((unsigned int8 *)(&y))+2);
     ....................    bit_clear(data1,7);
     ....................    *(((unsigned int8 *)(&y))+2) = data1;
     ....................    if(bit_test(data2,7))
     ....................    bit_set(*(((unsigned int8 *)(&y))+3),7);
     .................... #endif
     ....................
     ....................       y = (y - 1.0)/(y + 1.0);
     ....................
     ....................       y2=y*y;
     ....................
     ....................       res = pl[0]*y2 + pl[1];
     ....................       res = res*y2 + pl[2];
     ....................       res = res*y2 + pl[3];
     ....................
     ....................       r = ql[0]*y2 + ql[1];
     ....................       r = r*y2 + ql[2];
     ....................       r = r*y2 + ql[3];
     ....................
     ....................       res = y*res/r;
     .................... #if !defined(__PCD__)
     ....................       n = *((unsigned int8 *)(&x)) - 0x7E;
     .................... #endif
     .................... #if defined(__PCD__)
     ....................     data1 = *(((unsigned int8 *)(&x)+3));
     ....................     rotate_left(&data1,1);
     ....................     data2 = *(((unsigned int8 *)(&x)+2));
     ....................     if(bit_test (data2,7))
     ....................       bit_set(data1,0);
     ....................     n = data1 - 0x7E;
     .................... #endif
     ....................
     ....................       if (n<0)
     ....................          r = -(float32)-n;
     ....................       else
     ....................          r = (float32)n;
     ....................
     ....................       res += r*LN2;
     ....................    }
     ....................
     ....................    else
     ....................       res = 0.0;
     ....................
     ....................    return(res);
     .................... }
     ....................
     .................... //Overloaded function for log() for PCD
     .................... // Overloaded function log() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 log(float48 x)
     .................... {
     ....................    float48 y, res, r, y2;
     ....................    unsigned int8  data1,data2;
     ....................    signed int8 n;
     ....................    #ifdef _ERRNO
     ....................    if(x <0)
     ....................    {
     ....................       errno=EDOM;
     ....................    }
     ....................    if(x ==0)
     ....................    {
     ....................       errno=ERANGE;
     ....................       return(0);
     ....................    }
     ....................    #endif
     ....................    y = x;
     ....................
     ....................    if (y != 1.0)
     ....................    {
     ....................
     ....................    #if !defined(__PCD__)
     ....................        *((unsigned int8 *)(&y)) = 0x7E;
     ....................    #endif
     ....................       data2 = *(((unsigned int8 *)(&y))+5);
     ....................       *(((unsigned int8 *)(&y))+5) = 0x3F;
     ....................       data1 = *(((unsigned int8 *)(&y))+4);
     ....................       bit_clear(data1,7);
     ....................       *(((unsigned int8 *)(&y))+4) = data1;
     ....................
     ....................       if(bit_test(data2,7))
     ....................          bit_set(*(((unsigned int8 *)(&y))+4),7);
     ....................       y = (y - 1.0)/(y + 1.0);
     ....................
     ....................       y2=y*y;
     ....................
     ....................       res = pl[0]*y2 + pl[1];
     ....................       res = res*y2 + pl[2];
     ....................       res = res*y2 + pl[3];
     ....................
     ....................       r = ql[0]*y2 + ql[1];
     ....................       r = r*y2 + ql[2];
     ....................       r = r*y2 + ql[3];
     ....................
     ....................       res = y*res/r;
     ....................
     ....................     data1 = *(((unsigned int8 *)(&x)+5));
     ....................     rotate_left(&data1,1);
     ....................     data2 = *(((unsigned int8 *)(&x)+4));
     ....................     if(bit_test (data2,7))
     ....................        bit_set(data1,0);
     ....................
     ....................     n = data1 - 0x7E;
     ....................
     ....................       if (n<0)
     ....................          r = -(float48)-n;
     ....................       else
     ....................          r = (float48)n;
     ....................
     ....................       res += r*LN2;
     ....................    }
     ....................
     ....................    else
     ....................       res = 0.0;
     ....................
     ....................    return(res);
     .................... }
     ....................
     .................... // Overloaded function log() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float32 const pl_64[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};
     .................... float32 const ql_64[4] = {1.0000000,  -8.1354259, 16.780517, -9.9300943};
     .................... #endif
     .................... float64 log(float64 x)
     .................... {
     ....................    float64 y, res, r, y2;
     ....................    unsigned int16  data1,data2;
     ....................    unsigned int16 *p;
     ....................    signed int16 n;
     ....................    #ifdef _ERRNO
     ....................    if(x <0)
     ....................    {
     ....................       errno=EDOM;
     ....................    }
     ....................    if(x ==0)
     ....................    {
     ....................       errno=ERANGE;
     ....................       return(0);
     ....................    }
     ....................    #endif
     ....................    y = x;
     ....................
     ....................    if (y != 1.0)
     ....................    {
     ....................    #if !defined(__PCD__)
     ....................        *((unsigned int8 *)(&y)) = 0x7E;
     ....................    #endif
     ....................       p= (((unsigned int16 *)(&y))+3);
     ....................       data1 = *p;
     ....................       data2 = *p;
     ....................       data1 = 0x3FE;
     ....................       data1 = data1 <<4;
     ....................       if(bit_test (data2,15))
     ....................       bit_set(data1,15);
     ....................       data2 = data2 & 0x000F;
     ....................       data1 ^=data2;
     ....................
     ....................       *p = data1;
     ....................
     ....................       y = (y - 1.0)/(y + 1.0);
     ....................
     ....................       y2=y*y;
     ....................
     ....................       res = pl_64[0]*y2 + pl_64[1];
     ....................       res = res*y2 + pl_64[2];
     ....................       res = res*y2 + pl_64[3];
     ....................
     ....................       r = ql_64[0]*y2 + ql_64[1];
     ....................       r = r*y2 + ql_64[2];
     ....................       r = r*y2 + ql_64[3];
     ....................
     ....................       res = y*res/r;
     ....................
     ....................       p= (((unsigned int16 *)(&x))+3);
     ....................       data1 = *p;
     ....................       bit_clear(data1,15);
     ....................       data1 = data1 >>4;
     ....................       n = data1 - 0x3FE;
     ....................
     ....................
     ....................       if (n<0)
     ....................          r = -(float64)-n;
     ....................       else
     ....................          r = (float64)n;
     ....................
     ....................       res += r*LN2;
     ....................    }
     ....................
     ....................    else
     ....................       res = 0.0;
     ....................
     ....................    return(res);
     .................... }
     .................... #endif
     ....................
     ....................
     .................... #define LN10 2.3025850929940456
     ....................
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float log10(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : returns the the log base 10 of x
     .................... // Date : N/A
     .................... //
     .................... float32 log10(float32 x)
     .................... {
     ....................    float32 r;
     ....................
     ....................    r = log(x);
     ....................    r = r/LN10;
     ....................    return(r);
     .................... }
     ....................
     .................... //Overloaded functions for log10() for PCD
     .................... // Overloaded function log10() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 log10(float48 x)
     .................... {
     ....................    float48 r;
     ....................
     ....................    r = log(x);
     ....................    r = r/LN10;
     ....................    return(r);
     .................... }
     ....................
     .................... // Overloaded function log10() for data type - Float64
     .................... float64 log10(float64 x)
     .................... {
     ....................    float64 r;
     ....................
     ....................    r = log(x);
     ....................    r = r/LN10;
     ....................    return(r);
     .................... }
     .................... #endif
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float modf(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description :breaks the argument value int integral and fractional parts,
     .................... // ach of which have the same sign as the argument.  It stores the integral part
     .................... // as a float in the object pointed to by the iptr
     .................... // Returns : returns the signed fractional part of value.
     .................... // Date : N/A
     .................... //
     ....................
     .................... float32 modf(float32 value,float32 *iptr)
     .................... {
     ....................    *iptr=(value < 0.0)? ceil(value): floor(value);
     ....................    return(value - *iptr);
     .................... }
     .................... //Overloaded functions for modf() for PCD
     .................... // Overloaded function modf() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 modf(float48 value,float48 *iptr)
     .................... {
     ....................    *iptr=(value < 0.0)? ceil(value): floor(value);
     ....................    return(value - *iptr);
     .................... }
     .................... // Overloaded function modf() for data type - Float64
     .................... float64 modf(float64 value,float64 *iptr)
     .................... {
     ....................    *iptr=(value < 0.0)? ceil(value): floor(value);
     ....................    return(value - *iptr);
     .................... }
     .................... #endif
     ....................
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float pwr(float x,float y)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : returns the value (x^y)
     .................... // Date : N/A
     .................... // Note : 0 is returned when the function will generate an imaginary number
     .................... //
     .................... float32 pwr(float32 x,float32 y)
     .................... {
     ....................    if(0 > x && fmod(y, 1) == 0) {
     ....................       if(fmod(y, 2) == 0) {
     ....................          return (exp(log(-x) * y));
     ....................       } else {
     ....................          return (-exp(log(-x) * y));
     ....................       }
     ....................    } else if(0 > x && fmod(y, 1) != 0) {
     ....................       return 0;
     ....................    } else {
     ....................       if(x != 0 || 0 >= y) {
     ....................          return (exp(log(x) * y));
     ....................       }
     ....................    }
     .................... }
     .................... //Overloaded functions for pwr() for PCD
     .................... // Overloaded function pwr() for data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 pwr(float48 x,float48 y)
     .................... {
     ....................    if(0 > x && fmod(y, 1) == 0) {
     ....................       if(fmod(y, 2) == 0) {
     ....................          return (exp(log(-x) * y));
     ....................       } else {
     ....................          return (-exp(log(-x) * y));
     ....................       }
     ....................    } else if(0 > x && fmod(y, 1) != 0) {
     ....................       return 0;
     ....................    } else {
     ....................       if(x != 0 || 0 >= y) {
     ....................          return (exp(log(x) * y));
     ....................       }
     ....................    }
     .................... }
     .................... // Overloaded function pwr() for data type - Float64
     .................... float64 pwr(float64 x,float64 y)
     .................... {
     ....................    if(0 > x && fmod(y, 1) == 0) {
     ....................       if(fmod(y, 2) == 0) {
     ....................          return (exp(log(-x) * y));
     ....................       } else {
     ....................          return (-exp(log(-x) * y));
     ....................       }
     ....................    } else if(0 > x && fmod(y, 1) != 0) {
     ....................       return 0;
     ....................    } else {
     ....................       if(x != 0 || 0 >= y) {
     ....................          return (exp(log(x) * y));
     ....................       }
     ....................    }
     .................... }
     .................... #endif
     ....................
     .................... //////////////////// Power functions ////////////////////
     ....................
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float pow(float x,float y)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : returns the value (x^y)
     .................... // Date : N/A
     .................... // Note : 0 is returned when the function will generate an imaginary number
     .................... //
     .................... float32 pow(float32 x,float32 y)
     .................... {
     ....................    if(0 > x && fmod(y, 1) == 0) {
     ....................       if(fmod(y, 2) == 0) {
     ....................          return (exp(log(-x) * y));
     ....................       } else {
     ....................          return (-exp(log(-x) * y));
     ....................       }
     ....................    } else if(0 > x && fmod(y, 1) != 0) {
     ....................       return 0;
     ....................    } else {
     ....................       if(x != 0 || 0 >= y) {
     ....................          return (exp(log(x) * y));
     ....................       }
     ....................    }
     .................... }
     .................... //Overloaded functions for pow() for PCD
     .................... // Overloaded function for pow() data type - Float48
     .................... #if defined(__PCD__)
     .................... float48 pow(float48 x,float48 y)
     .................... {
     ....................    if(0 > x && fmod(y, 1) == 0) {
     ....................       if(fmod(y, 2) == 0) {
     ....................          return (exp(log(-x) * y));
     ....................       } else {
     ....................          return (-exp(log(-x) * y));
     ....................       }
     ....................    } else if(0 > x && fmod(y, 1) != 0) {
     ....................       return 0;
     ....................    } else {
     ....................       if(x != 0 || 0 >= y) {
     ....................          return (exp(log(x) * y));
     ....................       }
     ....................    }
     .................... }
     ....................
     .................... // Overloaded function pow() for data type - Float64
     .................... float64 pow(float64 x,float64 y)
     .................... {
     ....................    if(0 > x && fmod(y, 1) == 0) {
     ....................       if(fmod(y, 2) == 0) {
     ....................          return (exp(log(-x) * y));
     ....................       } else {
     ....................          return (-exp(log(-x) * y));
     ....................       }
     ....................    } else if(0 > x && fmod(y, 1) != 0) {
     ....................       return 0;
     ....................    } else {
     ....................       if(x != 0 || 0 >= y) {
     ....................          return (exp(log(x) * y));
     ....................       }
     ....................    }
     .................... }
     .................... #endif
     ....................
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... //   float sqrt(float x)
     .................... ////////////////////////////////////////////////////////////////////////////
     .................... // Description : returns the square root of x
     .................... // Date : N/A
     .................... //
     .................... float32 sqrt(float32 x)
     .................... {
     ....................    float32 y, res;
     ....................    #if defined(__PCD__)
     ....................    unsigned int16 data1,data2;
     ....................    #endif
     ....................    BYTE *p;
     ....................
     ....................    #ifdef _ERRNO
     ....................    if(x < 0)