Merge branch 'features/r2_11_2/JAL-3821_reinstate_patch' into develop
[jalview.git] / unused / javajs / util / BC.java
1 package javajs.util;
2
3 /**
4  * byte converter
5  * 
6  * 
7  * @author Bob Hanson hansonr@stolaf.edu
8  * 
9  */
10 public class BC {
11
12   public BC() {
13     // unnecessary to instantialize unless subclassed
14   }
15   
16   public static float bytesToFloat(byte[] bytes, int j, boolean isBigEndian) throws Exception {
17     return intToFloat(bytesToInt(bytes, j, isBigEndian));
18   }
19
20   public static int bytesToShort(byte[] bytes, int j, boolean isBigEndian) {
21     int n = (isBigEndian ? (bytes[j + 1] & 0xff) | (bytes[j] & 0xff) << 8
22         : (bytes[j++] & 0xff) | (bytes[j++] & 0xff) << 8);
23       return (n > 0x7FFF ? n - 0x10000 : n);
24   }
25
26   public static int bytesToInt(byte[] bytes, int j, boolean isBigEndian) {
27     int n = (isBigEndian ? (bytes[j + 3] & 0xff) | (bytes[j + 2] & 0xff) << 8
28         | (bytes[j + 1] & 0xff) << 16 | (bytes[j] & 0xff) << 24
29         : (bytes[j++] & 0xff) | (bytes[j++] & 0xff) << 8
30             | (bytes[j++] & 0xff) << 16 | (bytes[j++] & 0xff) << 24);
31     
32     return (/** @j2sNative (n|0) || */ n); 
33 //    /**
34 //     * xxxxxxj2sNative
35 //     * 
36 //     * return (n > 0x7FFFFFFF ? n - 0x100000000 : n);
37 //     *   
38 //     */
39 //    {
40 //      return n;
41 //    }
42   }
43
44   public static int intToSignedInt(int n) {
45           
46             return (/** @j2sNative n || */ n); 
47
48 //    /**
49 //     * xxxxxxj2sNative
50 //     * 
51 //     * return (n > 0x7FFFFFFF ? n - 0x100000000 : n);
52 //     *   
53 //     */
54 //    {
55 //      return n;
56 //    }    
57   }
58   public static float intToFloat(int x) throws Exception {
59     
60 //    // see http://en.wikipedia.org/wiki/Binary32
61 //    // 
62 //    // [sign]      [8 bits power] [23 bits fraction]
63 //    // 0x80000000  0x7F800000      0x7FFFFF
64 //    // 
65 //    // (untested)
66 //              if (x == 0)
67 //                      return 0;
68 //      boolean isJS = /** xxxxxxj2sNative true | */false;
69 //      
70 //      
71 //      if (isJS) {
72 //        if (fracIEEE == null)
73 //            setFracIEEE();            
74 //        int m =  ((x & 0x7F800000) >> 23);
75 //        *       return ((x & 0x80000000) == 0 ? 1 : -1) * o.shiftIEEE$D$I((x & 0x7FFFFF) | 0x800000, m - 149);
76 //
77 //      }
78 //       /** 
79 //     * 
80 //     * xxxxxxj2sNative
81 //     * 
82 //     *       if (x == 0) return 0;
83 //     *       var o = javajs.util.BC;
84 //     *       if (o.fracIEEE$ == null)
85 //     *         o.setFracIEEE$();
86 //     *       var m = ((x & 0x7F800000) >> 23);
87 //     *       return ((x & 0x80000000) == 0 ? 1 : -1) * o.shiftIEEE$D$I((x & 0x7FFFFF) | 0x800000, m - 149);
88 //     *  
89 //     */
90 //    {
91     return Float.intBitsToFloat(x);
92  //   }
93   }
94
95   /**
96    * see http://en.wikipedia.org/wiki/Binary64
97    *  
98    * not concerning ourselves with very small or very large numbers and getting
99    * this exactly right. Just need a float here.
100    * 
101    * @param bytes
102    * @param j
103    * @param isBigEndian
104    * @return float
105    */
106   public static float bytesToDoubleToFloat(byte[] bytes, int j, boolean isBigEndian) {
107     {
108       // IEEE754: sign (1 bit), exponent (11 bits), fraction (52 bits).
109       // seeeeeee eeeeffff ffffffff ffffffff ffffffff xxxxxxxx xxxxxxxx xxxxxxxx
110       //     b1      b2       b3       b4       b5    ---------float ignores----
111
112         if (fracIEEE == null)
113            setFracIEEE();
114         
115       /**
116        * @j2sNative
117        *       var b1, b2, b3, b4, b5;
118        *       
119        *       if (isBigEndian) {
120        *       b1 = bytes[j] & 0xFF;
121        *       b2 = bytes[j + 1] & 0xFF;
122        *       b3 = bytes[j + 2] & 0xFF;
123        *       b4 = bytes[j + 3] & 0xFF;
124        *       b5 = bytes[j + 4] & 0xFF;
125        *       } else {
126        *       b1 = bytes[j + 7] & 0xFF;
127        *       b2 = bytes[j + 6] & 0xFF;
128        *       b3 = bytes[j + 5] & 0xFF;
129        *       b4 = bytes[j + 4] & 0xFF;
130        *       b5 = bytes[j + 3] & 0xFF;
131        *       }
132        *       var s = ((b1 & 0x80) == 0 ? 1 : -1);
133        *       var e = (((b1 & 0x7F) << 4) | (b2 >> 4)) - 1026;
134        *       b2 = (b2 & 0xF) | 0x10;
135        *       return s * (C$.shiftIEEE$D$I(b2, e) +C$.shiftIEEE$D$I(b3, e - 8) + C$.shiftIEEE$D$I(b4, e - 16)
136        *         + C$.shiftIEEE$D$I(b5, e - 24));
137        */
138       {
139         double d;
140         
141         if (isBigEndian)
142           d = Double.longBitsToDouble((((long) bytes[j]) & 0xff) << 56
143              | (((long) bytes[j + 1]) & 0xff) << 48
144              | (((long) bytes[j + 2]) & 0xff) << 40
145              | (((long) bytes[j + 3]) & 0xff) << 32
146              | (((long) bytes[j + 4]) & 0xff) << 24
147              | (((long) bytes[j + 5]) & 0xff) << 16
148              | (((long) bytes[j + 6]) & 0xff) << 8 
149              | (((long) bytes[7]) & 0xff));
150         else
151           d = Double.longBitsToDouble((((long) bytes[j + 7]) & 0xff) << 56
152              | (((long) bytes[j + 6]) & 0xff) << 48
153              | (((long) bytes[j + 5]) & 0xff) << 40
154              | (((long) bytes[j + 4]) & 0xff) << 32
155              | (((long) bytes[j + 3]) & 0xff) << 24
156              | (((long) bytes[j + 2]) & 0xff) << 16
157              | (((long) bytes[j + 1]) & 0xff) << 8 
158              | (((long) bytes[j]) & 0xff));
159         return (float) d;
160       }
161
162     }
163   }
164
165   private static float[] fracIEEE;
166
167   private static void setFracIEEE() {
168     fracIEEE = new float[270];
169     for (int i = 0; i < 270; i++)
170       fracIEEE[i] = (float) Math.pow(2, i - 141);
171     //    System.out.println(fracIEEE[0] + "  " + Parser.FLOAT_MIN_SAFE);
172     //    System.out.println(fracIEEE[269] + "  " + Float.MAX_VALUE);
173   }
174
175   /**
176    * only concerned about reasonable float values here -- private but not designated; called by JavaScript
177    * 
178    * @param f
179    * @param i
180    * @return f * 2^i
181    */
182   static double shiftIEEE(double f, int i) {
183     if (f == 0 || i < -140)
184       return 0;
185     if (i > 128)
186       return Float.MAX_VALUE;
187     return f * fracIEEE[i + 140];
188   }
189
190 //  static {
191 //    setFracIEEE();
192 //    for (int i = -50; i < 50; i++) {
193 //      float f = i * (float) (Math.random() * Math.pow(2, Math.random() * 100 - 50));
194 //      int x = Float.floatToIntBits(f);
195 //      int m = ((x & 0x7F800000) >> 23);
196 //      float f1 = (float) (f == 0 ? 0 : ((x & 0x80000000) == 0 ? 1 : -1) * shiftIEEE((x & 0x7FFFFF) | 0x800000, m - 149));
197 //      System.out.println(f + "  " + f1);
198 //    }
199 //    System.out.println("binarydo");
200 //  }
201
202
203
204 }