BitUtils.java
上传用户:hygd004
上传日期:2022-07-01
资源大小:246k
文件大小:4k
源码类别:

J2ME

开发平台:

Java

  1. // $Id: BitUtils.java,v 1.1 2004/07/29 03:45:31 Dave Exp $
  2. /*
  3.  * BitUtils.java
  4.  * Copyright (C) 2003, 2004 David Clausen
  5.  *
  6.  * This program is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU General Public License
  8.  * as published by the Free Software Foundation; either version 2
  9.  * of the License, or (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  *
  20.  */
  21. package net.dclausen.microfloat;
  22. /**
  23.  * Helper class providing bit-shift functions which are used internally by
  24.  * the <code>Float</code> and <code>Double</code> classes.  
  25.  */
  26. final class BitUtils {
  27.   private BitUtils() {
  28.   }
  29.   
  30.   /**
  31.    * Returns the number of contiguous 0 bits starting with the most significant
  32.    * bit of x.
  33.    */
  34.   static int countLeadingZeros(int x) {
  35.     if (x <= 0) {
  36.       if (x == 0) {
  37.         return 32;
  38.       }
  39.       return 0;
  40.     }
  41.     int count = 0;
  42.     if ((x & 0xffff0000) == 0) {
  43.       x <<= 16;
  44.       count = 16;
  45.     }
  46.     if ((x & 0xff000000) == 0) {
  47.       x <<= 8;
  48.       count += 8;
  49.     }
  50.     while (x > 0) {
  51.       count++;
  52.       x <<= 1;
  53.     }
  54.     return count;
  55.   }    
  56.   /**
  57.    * Returns the number of contiguous 0 bits starting with the most significant
  58.    * bit of x.
  59.    */
  60.   static int countLeadingZeros(long x) {
  61.     int c = countLeadingZeros((int) (x >> 32));
  62.     if (c == 32) {
  63.       return countLeadingZeros((int) x) + 32;
  64.     }
  65.     return c;
  66.   }    
  67. //Download by http://www.codefans.net
  68.   /**
  69.    * Right-shift x by count bits, and if any of the shifted-off bits are 1, 
  70.    * set the least significant bit of the return value to 1.
  71.    */
  72.   static int stickyRightShift(int x, int count) {
  73.     if (count >= 32) {
  74.       return ((x == 0) ? 0 : 1);
  75.     } else if ((x << (32 - count)) == 0) {
  76.       return x >>> count;
  77.     } else {
  78.       return (x >>> count) | 1;
  79.     }
  80.   }
  81.   /**
  82.    * Right-shift x by count bits, and if any of the shifted-off bits are 1, 
  83.    * set the least significant bit of the return value to 1.
  84.    */
  85.   static long stickyRightShift(long x, int count) {
  86.     if (count >= 64) {
  87.       return ((x == 0) ? 0 : 1);
  88.     } else if ((x << (64 - count)) == 0) {
  89.       return x >>> count;
  90.     } else {
  91.       return (x >>> count) | 1;
  92.     }
  93.   }
  94.   /**
  95.    * Right-shift x by count bits, and round the result using half-even rounding.
  96.    */
  97.   static int roundingRightShift(int x, int count) {
  98.     int remainder;
  99.     if (count > 32) {
  100.       return 0;
  101.     } else if (count == 32) {
  102.       remainder = x;
  103.       x = 0;
  104.     } else {
  105.       remainder = x << (32 - count);
  106.       x >>>= count;
  107.     }
  108.     if ((remainder < 0) && ((remainder != 0x80000000) || ((x & 1) == 1))) {
  109.       return x + 1;
  110.     }
  111.     return x;
  112.   }
  113.   /**
  114.    * Right-shift x by count bits, and round the result using half-even rounding.
  115.    */
  116.   static long roundingRightShift(long x, int count) {
  117.     long remainder;
  118.     if (count > 64) {
  119.       return 0;
  120.     } else if (count == 64) {
  121.       remainder = x;
  122.       x = 0;
  123.     } else {
  124.       remainder = x << (64 - count);
  125.       x >>>= count;
  126.     }
  127.     if ((remainder < 0) 
  128.         && ((remainder != 0x8000000000000000L) || ((x & 1) == 1))) {
  129.       return x + 1;
  130.     }
  131.     return x;
  132.   }
  133. }