Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
MULDIV32.H
Package: MSDN_VC98.zip　[view]
Upload User: bangxh
Upload Date: 2007-01-31
Package Size: 42235k
Code Size: 4k
Category:

Windows Develop

Development Platform:

Visual C++

MULDIV32.H：Code Content
  1. //==========================================================================;
  2. //
  3. //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4. //  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5. //  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6. //  PURPOSE.
  7. //
  8. //  Copyright (C) 1992 - 1997 Microsoft Corporation.  All Rights Reserved.
  9. //
  10. //--------------------------------------------------------------------------;
  11. //
  12. //  muldiv32.h
  13. //
  14. //  Description:
  15. //      math routines for 32 bit signed and unsiged numbers.
  16. //
  17. //      MulDiv32(a,b,c) = (a * b) / c         (round down, signed)
  18. //
  19. //      MulDivRD(a,b,c) = (a * b) / c         (round down, unsigned)
  20. //      MulDivRN(a,b,c) = (a * b + c/2) / c   (round nearest, unsigned)
  21. //      MulDivRU(a,b,c) = (a * b + c-1) / c   (round up, unsigned)
  22. //
  23. //==========================================================================;
  25. #ifndef _INC_MULDIV32
  26. #define _INC_MULDIV32
  29. #ifndef INLINE
  30. #define INLINE __inline
  31. #endif
  34. #ifdef _X86_
  36.     //
  37.     //  Use 32-bit x86 assembly.
  38.     //
  40.     #pragma warning(disable:4035 4704)
  42.     INLINE LONG MulDiv32(LONG a,LONG b,LONG c)
  43.     {
  44.         _asm     mov     eax,dword ptr a  //  mov  eax, a
  45.         _asm     mov     ebx,dword ptr b  //  mov  ebx, b
  46.         _asm     mov     ecx,dword ptr c  //  mov  ecx, c
  47.         _asm     imul    ebx              //  imul ebx
  48.         _asm     idiv    ecx              //  idiv ecx
  49.         _asm  shld  edx, eax, 16     //  shld edx, eax, 16
  51.     } // MulDiv32()
  53.     INLINE DWORD MulDivRN(DWORD a,DWORD b,DWORD c)
  54.     {
  55.         _asm     mov     eax,dword ptr a  //  mov  eax, a
  56.         _asm     mov     ebx,dword ptr b  //  mov  ebx, b
  57.         _asm     mov     ecx,dword ptr c  //  mov  ecx, c
  58.         _asm     mul     ebx              //  mul  ebx
  59.         _asm     mov     ebx,ecx          //  mov  ebx,ecx
  60.         _asm     shr     ebx,1            //  sar  ebx,1
  61.         _asm     add     eax,ebx          //  add  eax,ebx
  62.         _asm     adc     edx,0            //  adc  edx,0
  63.         _asm     div     ecx              //  div  ecx
  64.         _asm     shld    edx, eax, 16     //  shld edx, eax, 16
  66.     } // MulDiv32()
  68.     INLINE DWORD MulDivRU(DWORD a,DWORD b,DWORD c)
  69.     {
  70.         _asm     mov     eax,dword ptr a  //  mov  eax, a
  71.         _asm     mov     ebx,dword ptr b  //  mov  ebx, b
  72.         _asm     mov     ecx,dword ptr c  //  mov  ecx, c
  73.         _asm     mul     ebx              //  mul  ebx
  74.         _asm     mov     ebx,ecx          //  mov  ebx,ecx
  75.         _asm     dec     ebx              //  dec  ebx
  76.         _asm     add     eax,ebx          //  add  eax,ebx
  77.         _asm     adc     edx,0            //  adc  edx,0
  78.         _asm     div     ecx              //  div  ecx
  79.         _asm     shld    edx, eax, 16     //  shld edx, eax, 16
  81.     } // MulDivRU32()
  83.     INLINE DWORD MulDivRD(DWORD a,DWORD b,DWORD c)
  84.     {
  85.         _asm     mov     eax,dword ptr a  //  mov  eax, a
  86.         _asm     mov     ebx,dword ptr b  //  mov  ebx, b
  87.         _asm     mov     ecx,dword ptr c  //  mov  ecx, c
  88.         _asm     mul     ebx              //  mul  ebx
  89.         _asm     div     ecx              //  div  ecx
  90.         _asm     shld    edx, eax, 16     //  shld edx, eax, 16
  92.     } // MulDivRD32()
  94.     #pragma warning(default:4035 4704)
  97. #else
  99.     //
  100.     //  Use C9 __int64 support for Daytona RISC platforms.
  101.     //
  103.     INLINE LONG MulDiv32( LONG a, LONG b, LONG c )
  104.     {
  105.         return (LONG)( Int32x32To64(a,b) / c );
  106.     }
  109.     INLINE DWORD MulDivRD( DWORD a, DWORD b, DWORD c )
  110.     {
  111.         return (DWORD)( UInt32x32To64(a,b) / c );
  112.     }
  115.     INLINE DWORD MulDivRN( DWORD a, DWORD b, DWORD c )
  116.     {
  117.         return (DWORD)( (UInt32x32To64(a,b)+c/2) / c );
  118.     }
  121.     INLINE DWORD MulDivRU( DWORD a, DWORD b, DWORD c )
  122.     {
  123.         return (DWORD)( (UInt32x32To64(a,b)+c-1) / c );
  124.     }
  126. #endif
  129. //
  130. //  some code references these by other names.
  131. //
  132. #define muldiv32    MulDivRN
  133. #define muldivrd32  MulDivRD
  134. #define muldivru32  MulDivRU
  136. #endif  // _INC_MULDIV32