traininfoservice/geo/MoreMath.java

// **********************************************************************
// 
// <copyright>
// 
//  BBN Technologies
//  10 Moulton Street
//  Cambridge, MA 02138
//  (617) 873-8000
// 
//  Copyright (C) BBNT Solutions LLC. All rights reserved.
// 
// </copyright>
// **********************************************************************
// 
// $Source: /cvs/distapps/openmap/src/openmap/com/bbn/openmap/MoreMath.java,v $
// $RCSfile: MoreMath.java,v $
// $Revision: 1.3.2.1 $
// $Date: 2004/10/14 18:26:37 $
// $Author: dietrick $
// 
// **********************************************************************

package dk.thoerup.traininfoservice.geo;

/**
 * MoreMath provides functions that are not part of the standard Math
 * class.
 * <p>
 * 
 * <pre>
 * 
 *  Functions:
 *       asinh(float x) - hyperbolic arcsine
 *       sinh(float x) - hyperbolic sine
 * 
 *  Need to Implement:
 *  Function                Definition                              
 *  Hyperbolic cosine       (e&circ;x+e&circ;-x)/2                            
 *  Hyperbolic tangent      (e&circ;x-e&circ;-x)/(e&circ;x+e&circ;-x)                   
 *  Hyperbolic arc cosine   2 log  (sqrt((x+1)/2) + sqrt((x-1)/2))  
 *  Hyperbolic arc tangent  (log  (1+x) - log (1-x))/2
 *  
 * </pre>
 */
public class MoreMath {

    /**
     * 2*Math.PI
     */
    final public static transient float TWO_PI = (float) Math.PI * 2.0f;

    /**
     * 2*Math.PI
     */
    final public static transient double TWO_PI_D = Math.PI * 2.0d;

    /**
     * Math.PI/2
     */
    final public static transient float HALF_PI = (float) Math.PI / 2.0f;

    /**
     * Math.PI/2
     */
    final public static transient double HALF_PI_D = Math.PI / 2.0d;

    // cannot construct
    private MoreMath() {}

    /**
     * Checks if a ~= b. Use this to test equality of floating point
     * numbers.
     * <p>
     * 
     * @param a double
     * @param b double
     * @param epsilon the allowable error
     * @return boolean
     */
    final public static boolean approximately_equal(double a, double b,
                                                    double epsilon) {
        return (Math.abs(a - b) <= epsilon);
    }

    /**
     * Checks if a ~= b. Use this to test equality of floating point
     * numbers.
     * <p>
     * 
     * @param a float
     * @param b float
     * @param epsilon the allowable error
     * @return boolean
     */
    final public static boolean approximately_equal(float a, float b,
                                                    float epsilon) {
        return (Math.abs(a - b) <= epsilon);
    }

    /**
     * Hyperbolic arcsin.
     * <p>
     * Hyperbolic arc sine: log (x+sqrt(1+x^2))
     * 
     * @param x float
     * @return float asinh(x)
     */
    public static final float asinh(float x) {
        return (float) Math.log(x + Math.sqrt(x * x + 1));
    }

    /**
     * Hyperbolic arcsin.
     * <p>
     * Hyperbolic arc sine: log (x+sqrt(1+x^2))
     * 
     * @param x double
     * @return double asinh(x)
     */
    public static final double asinh(double x) {
        return (double) Math.log(x + Math.sqrt(x * x + 1));
    }

    /**
     * Hyperbolic sin.
     * <p>
     * Hyperbolic sine: (e^x-e^-x)/2
     * 
     * @param x float
     * @return float sinh(x)
     */
    public static final float sinh(float x) {
        return (float) (Math.pow(Math.E, x) - Math.pow(Math.E, -x)) / 2.0f;
    }

    /**
     * Hyperbolic sin.
     * <p>
     * Hyperbolic sine: (e^x-e^-x)/2
     * 
     * @param x double
     * @return double sinh(x)
     */
    public static final double sinh(double x) {
        return (double) (Math.pow(Math.E, x) - Math.pow(Math.E, -x)) / 2.0d;
    }

    // HACK - are there functions that already exist?
    /**
     * Return sign of number.
     * 
     * @param x short
     * @return int sign -1, 1
     */
    public static final int sign(short x) {
        return (x < 0) ? -1 : 1;
    }

    /**
     * Return sign of number.
     * 
     * @param x int
     * @return int sign -1, 1
     */
    public static final int sign(int x) {
        return (x < 0) ? -1 : 1;
    }

    /**
     * Return sign of number.
     * 
     * @param x long
     * @return int sign -1, 1
     */
    public static final int sign(long x) {
        return (x < 0) ? -1 : 1;
    }

    /**
     * Return sign of number.
     * 
     * @param x float
     * @return int sign -1, 1
     */
    public static final int sign(float x) {
        return (x < 0f) ? -1 : 1;
    }

    /**
     * Return sign of number.
     * 
     * @param x double
     * @return int sign -1, 1
     */
    public static final int sign(double x) {
        return (x < 0d) ? -1 : 1;
    }

    /**
     * Check if number is odd.
     * 
     * @param x short
     * @return boolean
     */
    public static final boolean odd(short x) {
        return !even(x);
    }

    /**
     * Check if number is odd.
     * 
     * @param x int
     * @return boolean
     */
    public static final boolean odd(int x) {
        return !even(x);
    }

    /**
     * Check if number is odd.
     * 
     * @param x long
     * @return boolean
     */
    public static final boolean odd(long x) {
        return !even(x);
    }

    /**
     * Check if number is even.
     * 
     * @param x short
     * @return boolean
     */
    public static final boolean even(short x) {
        return ((x & 0x1) == 0);
    }

    /**
     * Check if number is even.
     * 
     * @param x int
     * @return boolean
     */
    public static final boolean even(int x) {
        return ((x & 0x1) == 0);
    }

    /**
     * Check if number is even.
     * 
     * @param x long
     * @return boolean
     */
    public static final boolean even(long x) {
        return ((x & 0x1) == 0);
    }

    /**
     * Converts a byte in the range of -128 to 127 to an int in the
     * range 0 - 255.
     * 
     * @param b (-128 &lt;= b &lt;= 127)
     * @return int (0 &lt;= b &lt;= 255)
     */
    public static final int signedToInt(byte b) {
        return ((int) b & 0xff);
    }

    /**
     * Converts a short in the range of -32768 to 32767 to an int in
     * the range 0 - 65535.
     * 
     * @param w (-32768 &lt;= b &lt;= 32767)
     * @return int (0 &lt;= b &lt;= 65535)
     */
    public static final int signedToInt(short w) {
        return ((int) w & 0xffff);
    }

    /**
     * Convert an int in the range of -2147483648 to 2147483647 to a
     * long in the range 0 to 4294967295.
     * 
     * @param x (-2147483648 &lt;= x &lt;= 2147483647)
     * @return long (0 &lt;= x &lt;= 4294967295)
     */
    public static final long signedToLong(int x) {
        return ((long) x & 0xFFFFFFFFL);
    }

    /**
     * Converts an int in the range of 0 - 65535 to an int in the
     * range of 0 - 255.
     * 
     * @param w int (0 &lt;= w &lt;= 65535)
     * @return int (0 &lt;= w &lt;= 255)
     */
    public static final int wordToByte(int w) {
        return w >> 8;
    }

    /**
     * Build short out of bytes (in big endian order).
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @return short
     */
    public static final short BuildShortBE(byte bytevec[], int offset) {
        return (short) (((int) (bytevec[0 + offset]) << 8) | (signedToInt(bytevec[1 + offset])));
    }

    /**
     * Build short out of bytes (in little endian order).
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @return short
     */
    public static final short BuildShortLE(byte bytevec[], int offset) {
        return (short) (((int) (bytevec[1 + offset]) << 8) | (signedToInt(bytevec[0 + offset])));
    }

    /**
     * Build short out of bytes.
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @param MSBFirst BE or LE?
     * @return short
     */
    public static final short BuildShort(byte bytevec[], int offset,
                                         boolean MSBFirst) {
        if (MSBFirst) {
            return (BuildShortBE(bytevec, offset));
        } else {
            return (BuildShortLE(bytevec, offset));
        }
    }

    /**
     * Build short out of bytes (in big endian order).
     * 
     * @param bytevec bytes
     * @param MSBFirst BE or LE?
     * @return short
     */

    public static final short BuildShortBE(byte bytevec[], boolean MSBFirst) {
        return BuildShortBE(bytevec, 0);
    }

    /**
     * Build short out of bytes (in little endian order).
     * 
     * @param bytevec bytes
     * @param MSBFirst BE or LE?
     * @return short
     */
    public static final short BuildShortLE(byte bytevec[], boolean MSBFirst) {
        return BuildShortLE(bytevec, 0);
    }

    /**
     * Build short out of bytes.
     * 
     * @param bytevec bytes
     * @param MSBFirst BE or LE?
     * @return short
     */
    public static final short BuildShort(byte bytevec[], boolean MSBFirst) {
        return BuildShort(bytevec, 0, MSBFirst);
    }

    /**
     * Build int out of bytes (in big endian order).
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @return int
     */
    public static final int BuildIntegerBE(byte bytevec[], int offset) {
        return (((int) (bytevec[0 + offset]) << 24)
                | (signedToInt(bytevec[1 + offset]) << 16)
                | (signedToInt(bytevec[2 + offset]) << 8) | (signedToInt(bytevec[3 + offset])));
    }

    /**
     * Build int out of bytes (in little endian order).
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @return int
     */
    public static final int BuildIntegerLE(byte bytevec[], int offset) {
        return (((int) (bytevec[3 + offset]) << 24)
                | (signedToInt(bytevec[2 + offset]) << 16)
                | (signedToInt(bytevec[1 + offset]) << 8) | (signedToInt(bytevec[0 + offset])));
    }

    /**
     * Build int out of bytes.
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @param MSBFirst BE or LE?
     * @return int
     */
    public static final int BuildInteger(byte bytevec[], int offset,
                                         boolean MSBFirst) {
        if (MSBFirst)
            return BuildIntegerBE(bytevec, offset);
        else
            return BuildIntegerLE(bytevec, offset);
    }

    /**
     * Build int out of bytes (in big endian order).
     * 
     * @param bytevec bytes
     * @return int
     */
    public static final int BuildIntegerBE(byte bytevec[]) {
        return BuildIntegerBE(bytevec, 0);
    }

    /**
     * Build int out of bytes (in little endian order).
     * 
     * @param bytevec bytes
     * @return int
     */
    public static final int BuildIntegerLE(byte bytevec[]) {
        return BuildIntegerLE(bytevec, 0);
    }

    /**
     * Build int out of bytes.
     * 
     * @param bytevec bytes
     * @param MSBFirst BE or LE?
     * @return int
     */
    public static final int BuildInteger(byte bytevec[], boolean MSBFirst) {
        if (MSBFirst)
            return BuildIntegerBE(bytevec, 0);
        else
            return BuildIntegerLE(bytevec, 0);
    }

    /**
     * Build long out of bytes (in big endian order).
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @return long
     */
    public static final long BuildLongBE(byte bytevec[], int offset) {
        return (((long) signedToInt(bytevec[0 + offset]) << 56)
                | ((long) signedToInt(bytevec[1 + offset]) << 48)
                | ((long) signedToInt(bytevec[2 + offset]) << 40)
                | ((long) signedToInt(bytevec[3 + offset]) << 32)
                | ((long) signedToInt(bytevec[4 + offset]) << 24)
                | ((long) signedToInt(bytevec[5 + offset]) << 16)
                | ((long) signedToInt(bytevec[6 + offset]) << 8) | ((long) signedToInt(bytevec[7 + offset])));
    }

    /**
     * Build long out of bytes (in little endian order).
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @return long
     */
    public static final long BuildLongLE(byte bytevec[], int offset) {
        return (((long) signedToInt(bytevec[7 + offset]) << 56)
                | ((long) signedToInt(bytevec[6 + offset]) << 48)
                | ((long) signedToInt(bytevec[5 + offset]) << 40)
                | ((long) signedToInt(bytevec[4 + offset]) << 32)
                | ((long) signedToInt(bytevec[3 + offset]) << 24)
                | ((long) signedToInt(bytevec[2 + offset]) << 16)
                | ((long) signedToInt(bytevec[1 + offset]) << 8) | ((long) signedToInt(bytevec[0 + offset])));
    }

    /**
     * Build long out of bytes.
     * 
     * @param bytevec bytes
     * @param offset byte offset
     * @param MSBFirst BE or LE?
     * @return long
     */
    public static final long BuildLong(byte bytevec[], int offset,
                                       boolean MSBFirst) {
        if (MSBFirst)
            return BuildLongBE(bytevec, offset);
        else
            return BuildLongLE(bytevec, offset);
    }

    /**
     * Build long out of bytes (in big endian order).
     * 
     * @param bytevec bytes
     * @return long
     */
    public static final long BuildLongBE(byte bytevec[]) {
        return BuildLongBE(bytevec, 0);
    }

    /**
     * Build long out of bytes (in little endian order).
     * 
     * @param bytevec bytes
     * @return long
     */
    public static final long BuildLongLE(byte bytevec[]) {
        return BuildLongLE(bytevec, 0);
    }

    /**
     * Build long out of bytes.
     * 
     * @param bytevec bytes
     * @param MSBFirst BE or LE?
     * @return long
     */
    public static final long BuildLong(byte bytevec[], boolean MSBFirst) {
        if (MSBFirst)
            return BuildLongBE(bytevec, 0);
        else
            return BuildLongLE(bytevec, 0);
    }

    /*
     * public static final void main(String[] args) { byte[] b = new
     * byte[4]; b[0] = (byte)0xff; b[1] = (byte)0x7f;
     * com.bbn.openmap.util.Debug.output("32767="+BuildShortLE(b, 0));
     * b[0] = (byte)0x7f; b[1] = (byte)0xff;
     * com.bbn.openmap.util.Debug.output("32767="+BuildShortBE(b, 0));
     * b[1] = (byte)0xff; b[2] = (byte)0xff; b[3] = (byte)0xff;
     * com.bbn.openmap.util.Debug.output("2147483647="+BuildIntegerBE(b,
     * 0));
     * com.bbn.openmap.util.Debug.output("maxuint="+signedToLong(0xffffffff)); }
     */
}
1	// **********************************************************************
2	//
3	// <copyright>
4	//
5	// BBN Technologies
6	// 10 Moulton Street
7	// Cambridge, MA 02138
8	// (617) 873-8000
9	//
10	// Copyright (C) BBNT Solutions LLC. All rights reserved.
11	//
12	// </copyright>
13	// **********************************************************************
14	//
15	// $Source: /cvs/distapps/openmap/src/openmap/com/bbn/openmap/MoreMath.java,v $
16	// $RCSfile: MoreMath.java,v $
17	// $Revision: 1.3.2.1 $
18	// $Date: 2004/10/14 18:26:37 $
19	// $Author: dietrick $
20	//
21	// **********************************************************************
22
23	package dk.thoerup.traininfoservice.geo;
24
25	/**
26	* MoreMath provides functions that are not part of the standard Math
27	* class.
28	* <p>
29	*
30	* <pre>
31	*
32	* Functions:
33	* asinh(float x) - hyperbolic arcsine
34	* sinh(float x) - hyperbolic sine
35	*
36	* Need to Implement:
37	* Function Definition
38	* Hyperbolic cosine (e&circ;x+e&circ;-x)/2
39	* Hyperbolic tangent (e&circ;x-e&circ;-x)/(e&circ;x+e&circ;-x)
40	* Hyperbolic arc cosine 2 log (sqrt((x+1)/2) + sqrt((x-1)/2))
41	* Hyperbolic arc tangent (log (1+x) - log (1-x))/2
42	*
43	* </pre>
44	*/
45	public class MoreMath {
46
47	/**
48	* 2*Math.PI
49	*/
50	final public static transient float TWO_PI = (float) Math.PI * 2.0f;
51
52	/**
53	* 2*Math.PI
54	*/
55	final public static transient double TWO_PI_D = Math.PI * 2.0d;
56
57	/**
58	* Math.PI/2
59	*/
60	final public static transient float HALF_PI = (float) Math.PI / 2.0f;
61
62	/**
63	* Math.PI/2
64	*/
65	final public static transient double HALF_PI_D = Math.PI / 2.0d;
66
67	// cannot construct
68	private MoreMath() {}
69
70	/**
71	* Checks if a ~= b. Use this to test equality of floating point
72	* numbers.
73	* <p>
74	*
75	* @param a double
76	* @param b double
77	* @param epsilon the allowable error
78	* @return boolean
79	*/
80	final public static boolean approximately_equal(double a, double b,
81	double epsilon) {
82	return (Math.abs(a - b) <= epsilon);
83	}
84
85	/**
86	* Checks if a ~= b. Use this to test equality of floating point
87	* numbers.
88	* <p>
89	*
90	* @param a float
91	* @param b float
92	* @param epsilon the allowable error
93	* @return boolean
94	*/
95	final public static boolean approximately_equal(float a, float b,
96	float epsilon) {
97	return (Math.abs(a - b) <= epsilon);
98	}
99
100	/**
101	* Hyperbolic arcsin.
102	* <p>
103	* Hyperbolic arc sine: log (x+sqrt(1+x^2))
104	*
105	* @param x float
106	* @return float asinh(x)
107	*/
108	public static final float asinh(float x) {
109	return (float) Math.log(x + Math.sqrt(x * x + 1));
110	}
111
112	/**
113	* Hyperbolic arcsin.
114	* <p>
115	* Hyperbolic arc sine: log (x+sqrt(1+x^2))
116	*
117	* @param x double
118	* @return double asinh(x)
119	*/
120	public static final double asinh(double x) {
121	return (double) Math.log(x + Math.sqrt(x * x + 1));
122	}
123
124	/**
125	* Hyperbolic sin.
126	* <p>
127	* Hyperbolic sine: (e^x-e^-x)/2
128	*
129	* @param x float
130	* @return float sinh(x)
131	*/
132	public static final float sinh(float x) {
133	return (float) (Math.pow(Math.E, x) - Math.pow(Math.E, -x)) / 2.0f;
134	}
135
136	/**
137	* Hyperbolic sin.
138	* <p>
139	* Hyperbolic sine: (e^x-e^-x)/2
140	*
141	* @param x double
142	* @return double sinh(x)
143	*/
144	public static final double sinh(double x) {
145	return (double) (Math.pow(Math.E, x) - Math.pow(Math.E, -x)) / 2.0d;
146	}
147
148	// HACK - are there functions that already exist?
149	/**
150	* Return sign of number.
151	*
152	* @param x short
153	* @return int sign -1, 1
154	*/
155	public static final int sign(short x) {
156	return (x < 0) ? -1 : 1;
157	}
158
159	/**
160	* Return sign of number.
161	*
162	* @param x int
163	* @return int sign -1, 1
164	*/
165	public static final int sign(int x) {
166	return (x < 0) ? -1 : 1;
167	}
168
169	/**
170	* Return sign of number.
171	*
172	* @param x long
173	* @return int sign -1, 1
174	*/
175	public static final int sign(long x) {
176	return (x < 0) ? -1 : 1;
177	}
178
179	/**
180	* Return sign of number.
181	*
182	* @param x float
183	* @return int sign -1, 1
184	*/
185	public static final int sign(float x) {
186	return (x < 0f) ? -1 : 1;
187	}
188
189	/**
190	* Return sign of number.
191	*
192	* @param x double
193	* @return int sign -1, 1
194	*/
195	public static final int sign(double x) {
196	return (x < 0d) ? -1 : 1;
197	}
198
199	/**
200	* Check if number is odd.
201	*
202	* @param x short
203	* @return boolean
204	*/
205	public static final boolean odd(short x) {
206	return !even(x);
207	}
208
209	/**
210	* Check if number is odd.
211	*
212	* @param x int
213	* @return boolean
214	*/
215	public static final boolean odd(int x) {
216	return !even(x);
217	}
218
219	/**
220	* Check if number is odd.
221	*
222	* @param x long
223	* @return boolean
224	*/
225	public static final boolean odd(long x) {
226	return !even(x);
227	}
228
229	/**
230	* Check if number is even.
231	*
232	* @param x short
233	* @return boolean
234	*/
235	public static final boolean even(short x) {
236	return ((x & 0x1) == 0);
237	}
238
239	/**
240	* Check if number is even.
241	*
242	* @param x int
243	* @return boolean
244	*/
245	public static final boolean even(int x) {
246	return ((x & 0x1) == 0);
247	}
248
249	/**
250	* Check if number is even.
251	*
252	* @param x long
253	* @return boolean
254	*/
255	public static final boolean even(long x) {
256	return ((x & 0x1) == 0);
257	}
258
259	/**
260	* Converts a byte in the range of -128 to 127 to an int in the
261	* range 0 - 255.
262	*
263	* @param b (-128 <= b <= 127)
264	* @return int (0 <= b <= 255)
265	*/
266	public static final int signedToInt(byte b) {
267	return ((int) b & 0xff);
268	}
269
270	/**
271	* Converts a short in the range of -32768 to 32767 to an int in
272	* the range 0 - 65535.
273	*
274	* @param w (-32768 <= b <= 32767)
275	* @return int (0 <= b <= 65535)
276	*/
277	public static final int signedToInt(short w) {
278	return ((int) w & 0xffff);
279	}
280
281	/**
282	* Convert an int in the range of -2147483648 to 2147483647 to a
283	* long in the range 0 to 4294967295.
284	*
285	* @param x (-2147483648 <= x <= 2147483647)
286	* @return long (0 <= x <= 4294967295)
287	*/
288	public static final long signedToLong(int x) {
289	return ((long) x & 0xFFFFFFFFL);
290	}
291
292	/**
293	* Converts an int in the range of 0 - 65535 to an int in the
294	* range of 0 - 255.
295	*
296	* @param w int (0 <= w <= 65535)
297	* @return int (0 <= w <= 255)
298	*/
299	public static final int wordToByte(int w) {
300	return w >> 8;
301	}
302
303	/**
304	* Build short out of bytes (in big endian order).
305	*
306	* @param bytevec bytes
307	* @param offset byte offset
308	* @return short
309	*/
310	public static final short BuildShortBE(byte bytevec[], int offset) {
311	return (short) (((int) (bytevec[0 + offset]) << 8) \| (signedToInt(bytevec[1 + offset])));
312	}
313
314	/**
315	* Build short out of bytes (in little endian order).
316	*
317	* @param bytevec bytes
318	* @param offset byte offset
319	* @return short
320	*/
321	public static final short BuildShortLE(byte bytevec[], int offset) {
322	return (short) (((int) (bytevec[1 + offset]) << 8) \| (signedToInt(bytevec[0 + offset])));
323	}
324
325	/**
326	* Build short out of bytes.
327	*
328	* @param bytevec bytes
329	* @param offset byte offset
330	* @param MSBFirst BE or LE?
331	* @return short
332	*/
333	public static final short BuildShort(byte bytevec[], int offset,
334	boolean MSBFirst) {
335	if (MSBFirst) {
336	return (BuildShortBE(bytevec, offset));
337	} else {
338	return (BuildShortLE(bytevec, offset));
339	}
340	}
341
342	/**
343	* Build short out of bytes (in big endian order).
344	*
345	* @param bytevec bytes
346	* @param MSBFirst BE or LE?
347	* @return short
348	*/
349
350	public static final short BuildShortBE(byte bytevec[], boolean MSBFirst) {
351	return BuildShortBE(bytevec, 0);
352	}
353
354	/**
355	* Build short out of bytes (in little endian order).
356	*
357	* @param bytevec bytes
358	* @param MSBFirst BE or LE?
359	* @return short
360	*/
361	public static final short BuildShortLE(byte bytevec[], boolean MSBFirst) {
362	return BuildShortLE(bytevec, 0);
363	}
364
365	/**
366	* Build short out of bytes.
367	*
368	* @param bytevec bytes
369	* @param MSBFirst BE or LE?
370	* @return short
371	*/
372	public static final short BuildShort(byte bytevec[], boolean MSBFirst) {
373	return BuildShort(bytevec, 0, MSBFirst);
374	}
375
376	/**
377	* Build int out of bytes (in big endian order).
378	*
379	* @param bytevec bytes
380	* @param offset byte offset
381	* @return int
382	*/
383	public static final int BuildIntegerBE(byte bytevec[], int offset) {
384	return (((int) (bytevec[0 + offset]) << 24)
385	\| (signedToInt(bytevec[1 + offset]) << 16)
386	\| (signedToInt(bytevec[2 + offset]) << 8) \| (signedToInt(bytevec[3 + offset])));
387	}
388
389	/**
390	* Build int out of bytes (in little endian order).
391	*
392	* @param bytevec bytes
393	* @param offset byte offset
394	* @return int
395	*/
396	public static final int BuildIntegerLE(byte bytevec[], int offset) {
397	return (((int) (bytevec[3 + offset]) << 24)
398	\| (signedToInt(bytevec[2 + offset]) << 16)
399	\| (signedToInt(bytevec[1 + offset]) << 8) \| (signedToInt(bytevec[0 + offset])));
400	}
401
402	/**
403	* Build int out of bytes.
404	*
405	* @param bytevec bytes
406	* @param offset byte offset
407	* @param MSBFirst BE or LE?
408	* @return int
409	*/
410	public static final int BuildInteger(byte bytevec[], int offset,
411	boolean MSBFirst) {
412	if (MSBFirst)
413	return BuildIntegerBE(bytevec, offset);
414	else
415	return BuildIntegerLE(bytevec, offset);
416	}
417
418	/**
419	* Build int out of bytes (in big endian order).
420	*
421	* @param bytevec bytes
422	* @return int
423	*/
424	public static final int BuildIntegerBE(byte bytevec[]) {
425	return BuildIntegerBE(bytevec, 0);
426	}
427
428	/**
429	* Build int out of bytes (in little endian order).
430	*
431	* @param bytevec bytes
432	* @return int
433	*/
434	public static final int BuildIntegerLE(byte bytevec[]) {
435	return BuildIntegerLE(bytevec, 0);
436	}
437
438	/**
439	* Build int out of bytes.
440	*
441	* @param bytevec bytes
442	* @param MSBFirst BE or LE?
443	* @return int
444	*/
445	public static final int BuildInteger(byte bytevec[], boolean MSBFirst) {
446	if (MSBFirst)
447	return BuildIntegerBE(bytevec, 0);
448	else
449	return BuildIntegerLE(bytevec, 0);
450	}
451
452	/**
453	* Build long out of bytes (in big endian order).
454	*
455	* @param bytevec bytes
456	* @param offset byte offset
457	* @return long
458	*/
459	public static final long BuildLongBE(byte bytevec[], int offset) {
460	return (((long) signedToInt(bytevec[0 + offset]) << 56)
461	\| ((long) signedToInt(bytevec[1 + offset]) << 48)
462	\| ((long) signedToInt(bytevec[2 + offset]) << 40)
463	\| ((long) signedToInt(bytevec[3 + offset]) << 32)
464	\| ((long) signedToInt(bytevec[4 + offset]) << 24)
465	\| ((long) signedToInt(bytevec[5 + offset]) << 16)
466	\| ((long) signedToInt(bytevec[6 + offset]) << 8) \| ((long) signedToInt(bytevec[7 + offset])));
467	}
468
469	/**
470	* Build long out of bytes (in little endian order).
471	*
472	* @param bytevec bytes
473	* @param offset byte offset
474	* @return long
475	*/
476	public static final long BuildLongLE(byte bytevec[], int offset) {
477	return (((long) signedToInt(bytevec[7 + offset]) << 56)
478	\| ((long) signedToInt(bytevec[6 + offset]) << 48)
479	\| ((long) signedToInt(bytevec[5 + offset]) << 40)
480	\| ((long) signedToInt(bytevec[4 + offset]) << 32)
481	\| ((long) signedToInt(bytevec[3 + offset]) << 24)
482	\| ((long) signedToInt(bytevec[2 + offset]) << 16)
483	\| ((long) signedToInt(bytevec[1 + offset]) << 8) \| ((long) signedToInt(bytevec[0 + offset])));
484	}
485
486	/**
487	* Build long out of bytes.
488	*
489	* @param bytevec bytes
490	* @param offset byte offset
491	* @param MSBFirst BE or LE?
492	* @return long
493	*/
494	public static final long BuildLong(byte bytevec[], int offset,
495	boolean MSBFirst) {
496	if (MSBFirst)
497	return BuildLongBE(bytevec, offset);
498	else
499	return BuildLongLE(bytevec, offset);
500	}
501
502	/**
503	* Build long out of bytes (in big endian order).
504	*
505	* @param bytevec bytes
506	* @return long
507	*/
508	public static final long BuildLongBE(byte bytevec[]) {
509	return BuildLongBE(bytevec, 0);
510	}
511
512	/**
513	* Build long out of bytes (in little endian order).
514	*
515	* @param bytevec bytes
516	* @return long
517	*/
518	public static final long BuildLongLE(byte bytevec[]) {
519	return BuildLongLE(bytevec, 0);
520	}
521
522	/**
523	* Build long out of bytes.
524	*
525	* @param bytevec bytes
526	* @param MSBFirst BE or LE?
527	* @return long
528	*/
529	public static final long BuildLong(byte bytevec[], boolean MSBFirst) {
530	if (MSBFirst)
531	return BuildLongBE(bytevec, 0);
532	else
533	return BuildLongLE(bytevec, 0);
534	}
535
536	/*
537	* public static final void main(String[] args) { byte[] b = new
538	* byte[4]; b[0] = (byte)0xff; b[1] = (byte)0x7f;
539	* com.bbn.openmap.util.Debug.output("32767="+BuildShortLE(b, 0));
540	* b[0] = (byte)0x7f; b[1] = (byte)0xff;
541	* com.bbn.openmap.util.Debug.output("32767="+BuildShortBE(b, 0));
542	* b[1] = (byte)0xff; b[2] = (byte)0xff; b[3] = (byte)0xff;
543	* com.bbn.openmap.util.Debug.output("2147483647="+BuildIntegerBE(b,
544	* 0));
545	* com.bbn.openmap.util.Debug.output("maxuint="+signedToLong(0xffffffff)); }
546	*/
547	}