Skip to content

R
riscv-gcc-1
Commit 98182da5 by Tom Tromey
Options

PushbackReader.java: Merged with Classpath. 

	* java/io/PushbackReader.java: Merged with Classpath.
	* java/util/Arrays.java: Updated from Classpath.

	* scripts/blocks.pl: New file.
	* java/lang/Character.java (Subset): New class.
	(UnicodeBlock): New class.

	* java/lang/Math.java (toDegrees, toRadians): New methods.

	* java/lang/Float.java: Implement Comparable.
	(compareTo): New methods.
	* java/lang/Double.java: Implement Comparable.
	(compareTo): New methods.

From-SVN: r37512
parent dd3b81b4
Showing with 1790 additions and 811 deletions
libjava/java/io/PushbackReader.java
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation /* PushbackReader.java -- An character stream that can unread chars
Copyright (C) 1998, 2000 Free Software Foundation, Inc.
This file is part of libgcj. This file is part of GNU Classpath.
This software is copyrighted work licensed under the terms of the GNU Classpath is free software; you can redistribute it and/or modify
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for it under the terms of the GNU General Public License as published by
details. */ the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.io; package java.io;
/** /**
* @author Warren Levy <warrenl@cygnus.com> * This subclass of <code>FilterReader</code> provides the ability to
* @date October 16, 1998. * unread data from a stream. It maintains an internal buffer of unread
* data that is supplied to the next read operation. This is conceptually
* similar to mark/reset functionality, except that in this case the
* position to reset the stream to does not need to be known in advance.
* <p>
* The default pushback buffer size one char, but this can be overridden
* by the creator of the stream.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Warren Levy <warrenl@cygnus.com>
*/
public class PushbackReader extends FilterReader
{
/*************************************************************************/
/*
* Class Variables
*/
/**
* This is the default buffer size
*/
private static final int DEFAULT_BUFFER_SIZE = 1;
/*************************************************************************/
/*
* Instance Variables
*/ */
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1 /**
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com. * This is the buffer that is used to store the pushed back data
* Status: Believed complete and correct. */
private char[] buf;
/**
* This is the position in the buffer from which the next char will be
* read. Bytes are stored in reverse order in the buffer, starting from
* <code>buf[buf.length - 1]</code> to <code>buf[0]</code>. Thus when
* <code>pos</code> is 0 the buffer is full and <code>buf.length</code> when
* it is empty
*/
private int pos;
/*************************************************************************/
/*
* Constructors
*/ */
public class PushbackReader extends FilterReader /**
* This method initializes a <code>PushbackReader</code> to read from the
* specified subordinate <code>Reader</code> with a default pushback buffer
* size of 1.
*
* @code in The subordinate stream to read from
*/
public
PushbackReader(Reader in)
{
this(in, DEFAULT_BUFFER_SIZE);
}
/*************************************************************************/
/**
* This method initializes a <code>PushbackReader</code> to read from the
* specified subordinate <code>Reader</code> with the specified buffer
* size
*
* @param in The subordinate <code>Reader</code> to read from
* @param bufsize The pushback buffer size to use
*/
public
PushbackReader(Reader in, int bufsize)
{
super(in);
if (bufsize < 0)
throw new IllegalArgumentException("buffer size must be positive");
buf = new char[bufsize];
pos = bufsize;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method closes the stream and frees any associated resources.
*
* @exception IOException If an error occurs.
*/
public void
close() throws IOException
{ {
/* Internal buffer array for data. */ synchronized (lock)
private char[] buf;
/* The current position in the buffer. */
private int pos;
public PushbackReader(Reader in)
{
this(in, 1);
}
public PushbackReader(Reader in, int size)
{
super(in);
if (size < 0)
throw new IllegalArgumentException();
buf = new char[size];
pos = buf.length;
}
public void close() throws IOException
{
synchronized (lock)
{ {
buf = null; buf = null;
super.close(); super.close();
} }
} }
/*************************************************************************/
/**
* This method throws an exception when called since this class does
* not support mark/reset.
*
* @param read_limit Not used.
*
* @exception IOException Always thrown to indicate mark/reset not supported.
*/
public void
mark(int read_limit) throws IOException
{
throw new IOException("mark not supported in this class");
}
/*************************************************************************/
/**
* This method returns <code>false</code> to indicate that it does not support
* mark/reset functionality.
*
* @return This method returns <code>false</code> to indicate that this class does not support mark/reset functionality
*
*/
public boolean
markSupported()
{
return(false);
}
/*************************************************************************/
/**
* This method always throws an IOException in this class because
* mark/reset functionality is not supported.
*
* @exception IOException Always thrown for this class
*/
public void
reset() throws IOException
{
throw new IOException("reset not supported in this class");
}
/*************************************************************************/
/**
* This method determines whether or not this stream is ready to be read.
* If it returns <code>false</code> to indicate that the stream is not
* ready, any attempt to read from the stream could (but is not
* guaranteed to) block.
* <p>
* This stream is ready to read if there are either chars waiting to be
* read in the pushback buffer or if the underlying stream is ready to
* be read.
*
* @return <code>true</code> if this stream is ready to be read, <code>false</code> otherwise
*
* @exception IOException If an error occurs
*/
public boolean
ready() throws IOException
{
synchronized (lock)
{
if (buf == null)
throw new IOException ("stream closed");
if (((buf.length - pos) > 0) || super.ready())
return(true);
else
return(false);
}
}
/*************************************************************************/
// Don't delete this method just because the spec says it shouldn't be there!
// See the CVS log for details.
/**
* This method skips the specified number of chars in the stream. It
* returns the actual number of chars skipped, which may be less than the
* requested amount.
* <p>
* This method first discards chars from the buffer, then calls the
* <code>skip</code> method on the underlying <code>Reader</code> to
* skip additional chars if necessary.
*
* @param num_chars The requested number of chars to skip
*
* @return The actual number of chars skipped.
*
* @exception IOException If an error occurs
*/
public long
skip(long num_chars) throws IOException
{
synchronized (lock)
{
if (num_chars <= 0)
return(0);
if ((buf.length - pos) >= num_chars)
{
pos += num_chars;
return(num_chars);
}
int chars_discarded = buf.length - pos;
pos = buf.length;
long chars_skipped = in.skip(num_chars - chars_discarded);
public boolean markSupported() return(chars_discarded + chars_skipped);
{ } // synchronized
return false; }
}
/*************************************************************************/
public int read() throws IOException /**
{ * This method reads an unsigned char from the input stream and returns it
synchronized (lock) * as an int in the range of 0-65535. This method also will return -1 if
* the end of the stream has been reached. The char returned will be read
* from the pushback buffer, unless the buffer is empty, in which case
* the char will be read from the underlying stream.
* <p>
* This method will block until the char can be read.
*
* @return The char read or -1 if end of stream
*
* @exception IOException If an error occurs
*/
public int
read() throws IOException
{
synchronized (lock)
{ {
if (buf == null) if (buf == null)
throw new IOException(); throw new IOException("stream closed");
if (pos < buf.length) if (pos == buf.length)
return ((int) buf[pos++]) & 0xFFFF; return(super.read());
return super.read(); ++pos;
return((buf[pos - 1] & 0xFFFF));
} }
} }
/*************************************************************************/
public int read(char[] b, int off, int len) throws IOException /**
{ * This method read chars from a stream and stores them into a caller
synchronized (lock) * supplied buffer. It starts storing the data at index <code>offset</code> into
* the buffer and attempts to read <code>len</code> chars. This method can
* return before reading the number of chars requested. The actual number
* of chars read is returned as an int. A -1 is returned to indicate the
* end of the stream.
* <p>
* This method will block until some data can be read.
* <p>
* This method first reads chars from the pushback buffer in order to
* satisfy the read request. If the pushback buffer cannot provide all
* of the chars requested, the remaining chars are read from the
* underlying stream.
*
* @param buf The array into which the chars read should be stored
* @param offset The offset into the array to start storing chars
* @param len The requested number of chars to read
*
* @return The actual number of chars read, or -1 if end of stream.
*
* @exception IOException If an error occurs.
*/
public synchronized int
read(char[] b, int offset, int len) throws IOException
{
synchronized (lock)
{ {
if (buf == null) if (buf == null)
throw new IOException(); throw new IOException("stream closed");
if (off < 0 || len < 0 || off + len > b.length) if (offset < 0 || len < 0 || offset + len > b.length)
throw new ArrayIndexOutOfBoundsException(); throw new ArrayIndexOutOfBoundsException();
int numBytes = Math.min(buf.length - pos, len); int numBytes = Math.min(buf.length - pos, len);
if (numBytes > 0) if (numBytes > 0)
{ {
System.arraycopy (buf, pos, b, off, numBytes); System.arraycopy (buf, pos, b, offset, numBytes);
pos += numBytes; pos += numBytes;
return numBytes; return numBytes;
} }
return super.read(b, off, len); return super.read(b, offset, len);
} }
} }
public boolean ready() throws IOException /*************************************************************************/
{
synchronized (lock) /**
* This method pushes a single char of data into the pushback buffer.
* The char pushed back is the one that will be returned as the first char
* of the next read.
* <p>
* If the pushback buffer is full, this method throws an exception.
* <p>
* The argument to this method is an <code>int</code>. Only the low eight bits
* of this value are pushed back.
*
* @param b The char to be pushed back, passed as an int
*
* @exception IOException If the pushback buffer is full.
*/
public void
unread(int b) throws IOException
{
synchronized (lock)
{ {
if (buf == null) if (buf == null)
throw new IOException(); throw new IOException("stream closed");
if (pos == 0)
throw new IOException("Pushback buffer is full");
if (buf.length - pos > 0) --pos;
return true; buf[pos] = (char)(b & 0xFFFF);
} // synchronized
return super.ready(); }
}
}
public void unread(int b) throws IOException /*************************************************************************/
{
synchronized (lock)
{
if (buf == null || pos <= 0)
throw new IOException();
buf[--pos] = (char) b; /**
} * This method pushes all of the chars in the passed char array into
} * the pushback buffer. These chars are pushed in reverse order so that
* the next char read from the stream after this operation will be
* <code>buf[0]</code> followed by <code>buf[1]</code>, etc.
* <p>
* If the pushback buffer cannot hold all of the requested chars, an
* exception is thrown.
*
* @param buf The char array to be pushed back
*
* @exception IOException If the pushback buffer is full
*/
public synchronized void
unread(char[] buf) throws IOException
{
unread(buf, 0, buf.length);
}
public void unread(char[] b) throws IOException /*************************************************************************/
{
unread(b, 0, b.length);
}
public void unread(char[] b, int off, int len) throws IOException /**
{ * This method pushed back chars from the passed in array into the pushback
synchronized (lock) * buffer. The chars from <code>buf[offset]</code> to <cdoe>buf[offset + len]</code>
* are pushed in reverse order so that the next char read from the stream
* after this operation will be <code>buf[offset]</code> followed by
* <code>buf[offset + 1]</code>, etc.
* <p>
* If the pushback buffer cannot hold all of the requested chars, an
* exception is thrown.
*
* @param buf The char array to be pushed back
* @param offset The index into the array where the chars to be push start
* @param len The number of chars to be pushed.
*
* @exception IOException If the pushback buffer is full
*/
public synchronized void
unread(char[] b, int offset, int len) throws IOException
{
synchronized (lock)
{ {
if (buf == null || pos < len) if (buf == null)
throw new IOException(); throw new IOException("stream closed");
if (pos < len)
throw new IOException("Pushback buffer is full");
// Note the order that these chars are being added is the opposite // Note the order that these chars are being added is the opposite
// of what would be done if they were added to the buffer one at a time. // of what would be done if they were added to the buffer one at a time.
// See the Java Class Libraries book p. 1397. // See the Java Class Libraries book p. 1397.
System.arraycopy(b, off, buf, pos - len, len); System.arraycopy(b, offset, buf, pos - len, len);
// Don't put this into the arraycopy above, an exception might be thrown // Don't put this into the arraycopy above, an exception might be thrown
// and in that case we don't want to modify pos. // and in that case we don't want to modify pos.
pos -= len; pos -= len;
} }
}
} }
} // class PushbackReader
libjava/java/lang/Character.java
...@@ -284,4 +284,208 @@ public final class Character implements Serializable, Comparable ...@@ -284,4 +284,208 @@ public final class Character implements Serializable, Comparable
// Private data. // Private data.
private char value; private char value;
public static class Subset
{
protected Subset (String name)
{
this.name = name;
}
public final boolean equals (Object obj)
{
return obj == this;
}
public final int hashCode ()
{
return super.hashCode ();
}
public final String toString ()
{
return name;
}
// Name of this subset.
private String name;
}
public static final class UnicodeBlock extends Subset
{
private UnicodeBlock (String name, char start, char end)
{
super (name);
this.start = start;
this.end = end;
}
public static UnicodeBlock of (char c)
{
// A special case we need.
if (c == '\uFEFF')
return SPECIALS;
// Do a binary search to find the correct subset.
int hi = blocks.length;
int lo = 0;
while (hi > lo)
{
int mid = (hi + lo) / 2;
UnicodeBlock ub = blocks[mid];
if (c < ub.start)
hi = mid;
else if (c > ub.end)
lo = mid;
else
return ub;
}
return null;
}
// Start and end characters.
private char start, end;
// Everything from here to the end of UnicodeBlock is
// automatically generated by the blocks.pl script.
public static final UnicodeBlock BASIC_LATIN = new UnicodeBlock ("Basic Latin", '\u0000', '\u007F');
public static final UnicodeBlock LATIN_1_SUPPLEMENT = new UnicodeBlock ("Latin-1 Supplement", '\u0080', '\u00FF');
public static final UnicodeBlock LATIN_EXTENDED_A = new UnicodeBlock ("Latin Extended-A", '\u0100', '\u017F');
public static final UnicodeBlock LATIN_EXTENDED_B = new UnicodeBlock ("Latin Extended-B", '\u0180', '\u024F');
public static final UnicodeBlock IPA_EXTENSIONS = new UnicodeBlock ("IPA Extensions", '\u0250', '\u02AF');
public static final UnicodeBlock SPACING_MODIFIER_LETTERS = new UnicodeBlock ("Spacing Modifier Letters", '\u02B0', '\u02FF');
public static final UnicodeBlock COMBINING_DIACRITICAL_MARKS = new UnicodeBlock ("Combining Diacritical Marks", '\u0300', '\u036F');
public static final UnicodeBlock GREEK = new UnicodeBlock ("Greek", '\u0370', '\u03FF');
public static final UnicodeBlock CYRILLIC = new UnicodeBlock ("Cyrillic", '\u0400', '\u04FF');
public static final UnicodeBlock ARMENIAN = new UnicodeBlock ("Armenian", '\u0530', '\u058F');
public static final UnicodeBlock HEBREW = new UnicodeBlock ("Hebrew", '\u0590', '\u05FF');
public static final UnicodeBlock ARABIC = new UnicodeBlock ("Arabic", '\u0600', '\u06FF');
public static final UnicodeBlock DEVANAGARI = new UnicodeBlock ("Devanagari", '\u0900', '\u097F');
public static final UnicodeBlock BENGALI = new UnicodeBlock ("Bengali", '\u0980', '\u09FF');
public static final UnicodeBlock GURMUKHI = new UnicodeBlock ("Gurmukhi", '\u0A00', '\u0A7F');
public static final UnicodeBlock GUJARATI = new UnicodeBlock ("Gujarati", '\u0A80', '\u0AFF');
public static final UnicodeBlock ORIYA = new UnicodeBlock ("Oriya", '\u0B00', '\u0B7F');
public static final UnicodeBlock TAMIL = new UnicodeBlock ("Tamil", '\u0B80', '\u0BFF');
public static final UnicodeBlock TELUGU = new UnicodeBlock ("Telugu", '\u0C00', '\u0C7F');
public static final UnicodeBlock KANNADA = new UnicodeBlock ("Kannada", '\u0C80', '\u0CFF');
public static final UnicodeBlock MALAYALAM = new UnicodeBlock ("Malayalam", '\u0D00', '\u0D7F');
public static final UnicodeBlock THAI = new UnicodeBlock ("Thai", '\u0E00', '\u0E7F');
public static final UnicodeBlock LAO = new UnicodeBlock ("Lao", '\u0E80', '\u0EFF');
public static final UnicodeBlock TIBETAN = new UnicodeBlock ("Tibetan", '\u0F00', '\u0FBF');
public static final UnicodeBlock GEORGIAN = new UnicodeBlock ("Georgian", '\u10A0', '\u10FF');
public static final UnicodeBlock HANGUL_JAMO = new UnicodeBlock ("Hangul Jamo", '\u1100', '\u11FF');
public static final UnicodeBlock LATIN_EXTENDED_ADDITIONAL = new UnicodeBlock ("Latin Extended Additional", '\u1E00', '\u1EFF');
public static final UnicodeBlock GREEK_EXTENDED = new UnicodeBlock ("Greek Extended", '\u1F00', '\u1FFF');
public static final UnicodeBlock GENERAL_PUNCTUATION = new UnicodeBlock ("General Punctuation", '\u2000', '\u206F');
public static final UnicodeBlock SUPERSCRIPTS_AND_SUBSCRIPTS = new UnicodeBlock ("Superscripts and Subscripts", '\u2070', '\u209F');
public static final UnicodeBlock CURRENCY_SYMBOLS = new UnicodeBlock ("Currency Symbols", '\u20A0', '\u20CF');
public static final UnicodeBlock COMBINING_MARKS_FOR_SYMBOLS = new UnicodeBlock ("Combining Marks for Symbols", '\u20D0', '\u20FF');
public static final UnicodeBlock LETTERLIKE_SYMBOLS = new UnicodeBlock ("Letterlike Symbols", '\u2100', '\u214F');
public static final UnicodeBlock NUMBER_FORMS = new UnicodeBlock ("Number Forms", '\u2150', '\u218F');
public static final UnicodeBlock ARROWS = new UnicodeBlock ("Arrows", '\u2190', '\u21FF');
public static final UnicodeBlock MATHEMATICAL_OPERATORS = new UnicodeBlock ("Mathematical Operators", '\u2200', '\u22FF');
public static final UnicodeBlock MISCELLANEOUS_TECHNICAL = new UnicodeBlock ("Miscellaneous Technical", '\u2300', '\u23FF');
public static final UnicodeBlock CONTROL_PICTURES = new UnicodeBlock ("Control Pictures", '\u2400', '\u243F');
public static final UnicodeBlock OPTICAL_CHARACTER_RECOGNITION = new UnicodeBlock ("Optical Character Recognition", '\u2440', '\u245F');
public static final UnicodeBlock ENCLOSED_ALPHANUMERICS = new UnicodeBlock ("Enclosed Alphanumerics", '\u2460', '\u24FF');
public static final UnicodeBlock BOX_DRAWING = new UnicodeBlock ("Box Drawing", '\u2500', '\u257F');
public static final UnicodeBlock BLOCK_ELEMENTS = new UnicodeBlock ("Block Elements", '\u2580', '\u259F');
public static final UnicodeBlock GEOMETRIC_SHAPES = new UnicodeBlock ("Geometric Shapes", '\u25A0', '\u25FF');
public static final UnicodeBlock MISCELLANEOUS_SYMBOLS = new UnicodeBlock ("Miscellaneous Symbols", '\u2600', '\u26FF');
public static final UnicodeBlock DINGBATS = new UnicodeBlock ("Dingbats", '\u2700', '\u27BF');
public static final UnicodeBlock CJK_SYMBOLS_AND_PUNCTUATION = new UnicodeBlock ("CJK Symbols and Punctuation", '\u3000', '\u303F');
public static final UnicodeBlock HIRAGANA = new UnicodeBlock ("Hiragana", '\u3040', '\u309F');
public static final UnicodeBlock KATAKANA = new UnicodeBlock ("Katakana", '\u30A0', '\u30FF');
public static final UnicodeBlock BOPOMOFO = new UnicodeBlock ("Bopomofo", '\u3100', '\u312F');
public static final UnicodeBlock HANGUL_COMPATIBILITY_JAMO = new UnicodeBlock ("Hangul Compatibility Jamo", '\u3130', '\u318F');
public static final UnicodeBlock KANBUN = new UnicodeBlock ("Kanbun", '\u3190', '\u319F');
public static final UnicodeBlock ENCLOSED_CJK_LETTERS_AND_MONTHS = new UnicodeBlock ("Enclosed CJK Letters and Months", '\u3200', '\u32FF');
public static final UnicodeBlock CJK_COMPATIBILITY = new UnicodeBlock ("CJK Compatibility", '\u3300', '\u33FF');
public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS = new UnicodeBlock ("CJK Unified Ideographs", '\u4E00', '\u9FFF');
public static final UnicodeBlock HANGUL_SYLLABLES = new UnicodeBlock ("Hangul Syllables", '\uAC00', '\uD7A3');
public static final UnicodeBlock HIGH_SURROGATES = new UnicodeBlock ("High Surrogates", '\uD800', '\uDB7F');
public static final UnicodeBlock HIGH_PRIVATE_USE_SURROGATES = new UnicodeBlock ("High Private Use Surrogates", '\uDB80', '\uDBFF');
public static final UnicodeBlock LOW_SURROGATES = new UnicodeBlock ("Low Surrogates", '\uDC00', '\uDFFF');
public static final UnicodeBlock PRIVATE_USE = new UnicodeBlock ("Private Use", '\uE000', '\uF8FF');
public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS = new UnicodeBlock ("CJK Compatibility Ideographs", '\uF900', '\uFAFF');
public static final UnicodeBlock ALPHABETIC_PRESENTATION_FORMS = new UnicodeBlock ("Alphabetic Presentation Forms", '\uFB00', '\uFB4F');
public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_A = new UnicodeBlock ("Arabic Presentation Forms-A", '\uFB50', '\uFDFF');
public static final UnicodeBlock COMBINING_HALF_MARKS = new UnicodeBlock ("Combining Half Marks", '\uFE20', '\uFE2F');
public static final UnicodeBlock CJK_COMPATIBILITY_FORMS = new UnicodeBlock ("CJK Compatibility Forms", '\uFE30', '\uFE4F');
public static final UnicodeBlock SMALL_FORM_VARIANTS = new UnicodeBlock ("Small Form Variants", '\uFE50', '\uFE6F');
public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_B = new UnicodeBlock ("Arabic Presentation Forms-B", '\uFE70', '\uFEFE');
public static final UnicodeBlock HALFWIDTH_AND_FULLWIDTH_FORMS = new UnicodeBlock ("Halfwidth and Fullwidth Forms", '\uFF00', '\uFFEF');
public static final UnicodeBlock SPECIALS = new UnicodeBlock ("Specials", '\uFFF0', '\uFFFD');
private static final UnicodeBlock[] blocks = {
BASIC_LATIN,
LATIN_1_SUPPLEMENT,
LATIN_EXTENDED_A,
LATIN_EXTENDED_B,
IPA_EXTENSIONS,
SPACING_MODIFIER_LETTERS,
COMBINING_DIACRITICAL_MARKS,
GREEK,
CYRILLIC,
ARMENIAN,
HEBREW,
ARABIC,
DEVANAGARI,
BENGALI,
GURMUKHI,
GUJARATI,
ORIYA,
TAMIL,
TELUGU,
KANNADA,
MALAYALAM,
THAI,
LAO,
TIBETAN,
GEORGIAN,
HANGUL_JAMO,
LATIN_EXTENDED_ADDITIONAL,
GREEK_EXTENDED,
GENERAL_PUNCTUATION,
SUPERSCRIPTS_AND_SUBSCRIPTS,
CURRENCY_SYMBOLS,
COMBINING_MARKS_FOR_SYMBOLS,
LETTERLIKE_SYMBOLS,
NUMBER_FORMS,
ARROWS,
MATHEMATICAL_OPERATORS,
MISCELLANEOUS_TECHNICAL,
CONTROL_PICTURES,
OPTICAL_CHARACTER_RECOGNITION,
ENCLOSED_ALPHANUMERICS,
BOX_DRAWING,
BLOCK_ELEMENTS,
GEOMETRIC_SHAPES,
MISCELLANEOUS_SYMBOLS,
DINGBATS,
CJK_SYMBOLS_AND_PUNCTUATION,
HIRAGANA,
KATAKANA,
BOPOMOFO,
HANGUL_COMPATIBILITY_JAMO,
KANBUN,
ENCLOSED_CJK_LETTERS_AND_MONTHS,
CJK_COMPATIBILITY,
CJK_UNIFIED_IDEOGRAPHS,
HANGUL_SYLLABLES,
HIGH_SURROGATES,
HIGH_PRIVATE_USE_SURROGATES,
LOW_SURROGATES,
PRIVATE_USE,
CJK_COMPATIBILITY_IDEOGRAPHS,
ALPHABETIC_PRESENTATION_FORMS,
ARABIC_PRESENTATION_FORMS_A,
COMBINING_HALF_MARKS,
CJK_COMPATIBILITY_FORMS,
SMALL_FORM_VARIANTS,
ARABIC_PRESENTATION_FORMS_B,
HALFWIDTH_AND_FULLWIDTH_FORMS,
SPECIALS
};
}
} }
libjava/java/lang/Double.java
...@@ -18,7 +18,7 @@ package java.lang; ...@@ -18,7 +18,7 @@ package java.lang;
* Status: Believed complete and correct. * Status: Believed complete and correct.
*/ */
public final class Double extends Number public final class Double extends Number implements Comparable
{ {
public static final double MIN_VALUE = 5e-324; public static final double MIN_VALUE = 5e-324;
public static final double MAX_VALUE = 1.7976931348623157e+308; public static final double MAX_VALUE = 1.7976931348623157e+308;
...@@ -147,5 +147,26 @@ public final class Double extends Number ...@@ -147,5 +147,26 @@ public final class Double extends Number
public static native long doubleToLongBits (double value); public static native long doubleToLongBits (double value);
public static native double longBitsToDouble (long bits); public static native double longBitsToDouble (long bits);
}
public int compareTo (Double d)
{
double v = d.value;
if (isNaN (value))
return isNaN (v) ? 1 : 0;
else if (isNaN (v))
return -1;
else if (value == 0.0 && v == -0.0)
return 1;
else if (value == -0.0 && v == 0.0)
return -1;
else if (value == v)
return 0;
return value > v ? 1 : -1;
}
public int compareTo (Object o)
{
return compareTo ((Double) o);
}
}
libjava/java/lang/Float.java
...@@ -18,7 +18,7 @@ package java.lang; ...@@ -18,7 +18,7 @@ package java.lang;
* Status: Believed complete and correct. * Status: Believed complete and correct.
*/ */
public final class Float extends Number public final class Float extends Number implements Comparable
{ {
public static final float MAX_VALUE = 3.4028235e+38f; public static final float MAX_VALUE = 3.4028235e+38f;
public static final float MIN_VALUE = 1.4e-45f; public static final float MIN_VALUE = 1.4e-45f;
...@@ -147,5 +147,25 @@ public final class Float extends Number ...@@ -147,5 +147,25 @@ public final class Float extends Number
public static native float intBitsToFloat (int bits); public static native float intBitsToFloat (int bits);
} public int compareTo (Float d)
{
float v = d.value;
if (isNaN (value))
return isNaN (v) ? 1 : 0;
else if (isNaN (v))
return -1;
else if (value == 0.0 && v == -0.0)
return 1;
else if (value == -0.0 && v == 0.0)
return -1;
else if (value == v)
return 0;
return value > v ? 1 : -1;
}
public int compareTo (Object o)
{
return compareTo ((Float) o);
}
}
libjava/java/lang/Math.java
/* Copyright (C) 1998, 1999 Free Software Foundation /* Copyright (C) 1998, 1999, 2000 Free Software Foundation
This file is part of libgcj. This file is part of libgcj.
...@@ -110,6 +110,16 @@ public final class Math ...@@ -110,6 +110,16 @@ public final class Math
public static native double max (double a, double b); public static native double max (double a, double b);
public static double toDegrees (double radians)
{
return radians * 180 / PI;
}
public static double toRadians (double degrees)
{
return degrees * PI / 180;
}
// Don't allow objects to be made. // Don't allow objects to be made.
private Math () private Math ()
{ {
......
libjava/java/util/Arrays.java
/* Arrays.java -- Utility class with methods to operate on arrays /* Arrays.java -- Utility class with methods to operate on arrays
Copyright (C) 1998, 1999 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -36,17 +36,20 @@ package java.util; ...@@ -36,17 +36,20 @@ package java.util;
* arrays, and a method to provide a List "view" of an array to facilitate * arrays, and a method to provide a List "view" of an array to facilitate
* using arrays with Collection-based APIs. * using arrays with Collection-based APIs.
*/ */
public class Arrays { public class Arrays
{
/** /**
* This class is non-instantiable. * This class is non-instantiable.
*/ */
private Arrays() { private Arrays()
{
} }
private static Comparator defaultComparator = new Comparator() { private static Comparator defaultComparator = new Comparator()
public int compare(Object o1, Object o2) { {
return ((Comparable)o1).compareTo(o2); public int compare(Object o1, Object o2)
{
return ((Comparable) o1).compareTo(o2);
} }
}; };
...@@ -64,21 +67,29 @@ public class Arrays { ...@@ -64,21 +67,29 @@ public class Arrays {
* found, where n is the index of the first value higher than key or * found, where n is the index of the first value higher than key or
* a.length if there is no such value. * a.length if there is no such value.
*/ */
public static int binarySearch(byte[] a, byte key) { public static int binarySearch(byte[]a, byte key)
{
int low = 0; int low = 0;
int hi = a.length - 1; int hi = a.length - 1;
int mid = 0; int mid = 0;
while (low <= hi) { while (low <= hi)
mid = (low + hi) >> 1; {
final byte d = a[mid]; mid = (low + hi) >> 1;
if (d == key) { final byte d = a[mid];
return mid; if (d == key)
} else if (d > key) { {
hi = mid - 1; return mid;
} else { }
low = ++mid; // This gets the insertion point right on the last loop else if (d > key)
{
hi = mid - 1;
}
else
{
// This gets the insertion point right on the last loop
low = ++mid;
}
} }
}
return -mid - 1; return -mid - 1;
} }
...@@ -96,21 +107,29 @@ public class Arrays { ...@@ -96,21 +107,29 @@ public class Arrays {
* found, where n is the index of the first value higher than key or * found, where n is the index of the first value higher than key or
* a.length if there is no such value. * a.length if there is no such value.
*/ */
public static int binarySearch(char[] a, char key) { public static int binarySearch(char[]a, char key)
{
int low = 0; int low = 0;
int hi = a.length - 1; int hi = a.length - 1;
int mid = 0; int mid = 0;
while (low <= hi) { while (low <= hi)
mid = (low + hi) >> 1; {
final char d = a[mid]; mid = (low + hi) >> 1;
if (d == key) { final char d = a[mid];
return mid; if (d == key)
} else if (d > key) { {
hi = mid - 1; return mid;
} else { }
low = ++mid; // This gets the insertion point right on the last loop else if (d > key)
{
hi = mid - 1;
}
else
{
// This gets the insertion point right on the last loop
low = ++mid;
}
} }
}
return -mid - 1; return -mid - 1;
} }
...@@ -128,21 +147,29 @@ public class Arrays { ...@@ -128,21 +147,29 @@ public class Arrays {
* found, where n is the index of the first value higher than key or * found, where n is the index of the first value higher than key or
* a.length if there is no such value. * a.length if there is no such value.
*/ */
public static int binarySearch(double[] a, double key) { public static int binarySearch(double[]a, double key)
{
int low = 0; int low = 0;
int hi = a.length - 1; int hi = a.length - 1;
int mid = 0; int mid = 0;
while (low <= hi) { while (low <= hi)
mid = (low + hi) >> 1; {
final double d = a[mid]; mid = (low + hi) >> 1;
if (d == key) { final double d = a[mid];
return mid; if (d == key)
} else if (d > key) { {
hi = mid - 1; return mid;
} else { }
low = ++mid; // This gets the insertion point right on the last loop else if (d > key)
{
hi = mid - 1;
}
else
{
// This gets the insertion point right on the last loop
low = ++mid;
}
} }
}
return -mid - 1; return -mid - 1;
} }
...@@ -160,21 +187,29 @@ public class Arrays { ...@@ -160,21 +187,29 @@ public class Arrays {
* found, where n is the index of the first value higher than key or * found, where n is the index of the first value higher than key or
* a.length if there is no such value. * a.length if there is no such value.
*/ */
public static int binarySearch(float[] a, float key) { public static int binarySearch(float[]a, float key)
{
int low = 0; int low = 0;
int hi = a.length - 1; int hi = a.length - 1;
int mid = 0; int mid = 0;
while (low <= hi) { while (low <= hi)
mid = (low + hi) >> 1; {
final float d = a[mid]; mid = (low + hi) >> 1;
if (d == key) { final float d = a[mid];
return mid; if (d == key)
} else if (d > key) { {
hi = mid - 1; return mid;
} else { }
low = ++mid; // This gets the insertion point right on the last loop else if (d > key)
{
hi = mid - 1;
}
else
{
// This gets the insertion point right on the last loop
low = ++mid;
}
} }
}
return -mid - 1; return -mid - 1;
} }
...@@ -192,21 +227,29 @@ public class Arrays { ...@@ -192,21 +227,29 @@ public class Arrays {
* found, where n is the index of the first value higher than key or * found, where n is the index of the first value higher than key or
* a.length if there is no such value. * a.length if there is no such value.
*/ */
public static int binarySearch(int[] a, int key) { public static int binarySearch(int[]a, int key)
{
int low = 0; int low = 0;
int hi = a.length - 1; int hi = a.length - 1;
int mid = 0; int mid = 0;
while (low <= hi) { while (low <= hi)
mid = (low + hi) >> 1; {
final int d = a[mid]; mid = (low + hi) >> 1;
if (d == key) { final int d = a[mid];
return mid; if (d == key)
} else if (d > key) { {
hi = mid - 1; return mid;
} else { }
low = ++mid; // This gets the insertion point right on the last loop else if (d > key)
{
hi = mid - 1;
}
else
{
// This gets the insertion point right on the last loop
low = ++mid;
}
} }
}
return -mid - 1; return -mid - 1;
} }
...@@ -224,21 +267,29 @@ public class Arrays { ...@@ -224,21 +267,29 @@ public class Arrays {
* found, where n is the index of the first value higher than key or * found, where n is the index of the first value higher than key or
* a.length if there is no such value. * a.length if there is no such value.
*/ */
public static int binarySearch(long[] a, long key) { public static int binarySearch(long[]a, long key)
{
int low = 0; int low = 0;
int hi = a.length - 1; int hi = a.length - 1;
int mid = 0; int mid = 0;
while (low <= hi) { while (low <= hi)
mid = (low + hi) >> 1; {
final long d = a[mid]; mid = (low + hi) >> 1;
if (d == key) { final long d = a[mid];
return mid; if (d == key)
} else if (d > key) { {
hi = mid - 1; return mid;
} else { }
low = ++mid; // This gets the insertion point right on the last loop else if (d > key)
{
hi = mid - 1;
}
else
{
// This gets the insertion point right on the last loop
low = ++mid;
}
} }
}
return -mid - 1; return -mid - 1;
} }
...@@ -256,21 +307,29 @@ public class Arrays { ...@@ -256,21 +307,29 @@ public class Arrays {
* found, where n is the index of the first value higher than key or * found, where n is the index of the first value higher than key or
* a.length if there is no such value. * a.length if there is no such value.
*/ */
public static int binarySearch(short[] a, short key) { public static int binarySearch(short[]a, short key)
{
int low = 0; int low = 0;
int hi = a.length - 1; int hi = a.length - 1;
int mid = 0; int mid = 0;
while (low <= hi) { while (low <= hi)
mid = (low + hi) >> 1; {
final short d = a[mid]; mid = (low + hi) >> 1;
if (d == key) { final short d = a[mid];
return mid; if (d == key)
} else if (d > key) { {
hi = mid - 1; return mid;
} else { }
low = ++mid; // This gets the insertion point right on the last loop else if (d > key)
{
hi = mid - 1;
}
else
{
// This gets the insertion point right on the last loop
low = ++mid;
}
} }
}
return -mid - 1; return -mid - 1;
} }
...@@ -279,21 +338,29 @@ public class Arrays { ...@@ -279,21 +338,29 @@ public class Arrays {
* @exception NullPointerException if the specified comparator is null. * @exception NullPointerException if the specified comparator is null.
* @exception ClassCastException if the objects are not comparable by c. * @exception ClassCastException if the objects are not comparable by c.
*/ */
private static int objectSearch(Object[] a, Object key, final Comparator c) { private static int objectSearch(Object[]a, Object key, final Comparator c)
{
int low = 0; int low = 0;
int hi = a.length - 1; int hi = a.length - 1;
int mid = 0; int mid = 0;
while (low <= hi) { while (low <= hi)
mid = (low + hi) >> 1; {
final int d = c.compare(key, a[mid]); mid = (low + hi) >> 1;
if (d == 0) { final int d = c.compare(key, a[mid]);
return mid; if (d == 0)
} else if (d < 0) { {
hi = mid - 1; return mid;
} else { }
low = ++mid; // This gets the insertion point right on the last loop else if (d < 0)
{
hi = mid - 1;
}
else
{
// This gets the insertion point right on the last loop
low = ++mid;
}
} }
}
return -mid - 1; return -mid - 1;
} }
...@@ -316,7 +383,8 @@ public class Arrays { ...@@ -316,7 +383,8 @@ public class Arrays {
* elements of a * elements of a
* @exception NullPointerException if a null element has compareTo called * @exception NullPointerException if a null element has compareTo called
*/ */
public static int binarySearch(Object[] a, Object key) { public static int binarySearch(Object[]a, Object key)
{
return objectSearch(a, key, defaultComparator); return objectSearch(a, key, defaultComparator);
} }
...@@ -339,7 +407,8 @@ public class Arrays { ...@@ -339,7 +407,8 @@ public class Arrays {
* @exception ClassCastException if key could not be compared with one of the * @exception ClassCastException if key could not be compared with one of the
* elements of a * elements of a
*/ */
public static int binarySearch(Object[] a, Object key, Comparator c) { public static int binarySearch(Object[]a, Object key, Comparator c)
{
return objectSearch(a, key, c); return objectSearch(a, key, c);
} }
...@@ -351,28 +420,35 @@ public class Arrays { ...@@ -351,28 +420,35 @@ public class Arrays {
* @returns true if a1 and a2 are both null, or if a2 is of the same length * @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i] * as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/ */
public static boolean equals(byte[] a1, byte[] a2) { public static boolean equals(byte[]a1, byte[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (a1[i] != a2[i])
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -385,28 +461,35 @@ public class Arrays { ...@@ -385,28 +461,35 @@ public class Arrays {
* @returns true if a1 and a2 are both null, or if a2 is of the same length * @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i] * as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/ */
public static boolean equals(char[] a1, char[] a2) { public static boolean equals(char[]a1, char[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (a1[i] != a2[i])
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -419,28 +502,35 @@ public class Arrays { ...@@ -419,28 +502,35 @@ public class Arrays {
* @returns true if a1 and a2 are both null, or if a2 is of the same length * @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i] * as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/ */
public static boolean equals(double[] a1, double[] a2) { public static boolean equals(double[]a1, double[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (a1[i] != a2[i])
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -453,28 +543,35 @@ public class Arrays { ...@@ -453,28 +543,35 @@ public class Arrays {
* @returns true if a1 and a2 are both null, or if a2 is of the same length * @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i] * as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/ */
public static boolean equals(float[] a1, float[] a2) { public static boolean equals(float[]a1, float[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (a1[i] != a2[i])
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -487,28 +584,35 @@ public class Arrays { ...@@ -487,28 +584,35 @@ public class Arrays {
* @returns true if a1 and a2 are both null, or if a2 is of the same length * @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i] * as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/ */
public static boolean equals(long[] a1, long[] a2) { public static boolean equals(long[]a1, long[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (a1[i] != a2[i])
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -521,28 +625,35 @@ public class Arrays { ...@@ -521,28 +625,35 @@ public class Arrays {
* @returns true if a1 and a2 are both null, or if a2 is of the same length * @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i] * as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/ */
public static boolean equals(short[] a1, short[] a2) { public static boolean equals(short[]a1, short[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (a1[i] != a2[i])
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -555,28 +666,35 @@ public class Arrays { ...@@ -555,28 +666,35 @@ public class Arrays {
* @returns true if a1 and a2 are both null, or if a2 is of the same length * @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i] * as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/ */
public static boolean equals(boolean[] a1, boolean[] a2) { public static boolean equals(boolean[]a1, boolean[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (a1[i] != a2[i])
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -589,28 +707,35 @@ public class Arrays { ...@@ -589,28 +707,35 @@ public class Arrays {
* @returns true if a1 and a2 are both null, or if a2 is of the same length * @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i] * as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/ */
public static boolean equals(int[] a1, int[] a2) { public static boolean equals(int[]a1, int[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (a1[i] != a2[i])
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -624,28 +749,35 @@ public class Arrays { ...@@ -624,28 +749,35 @@ public class Arrays {
* as a2, and for each 0 <= i < a.length, a1[i] == null ? a2[i] == null : * as a2, and for each 0 <= i < a.length, a1[i] == null ? a2[i] == null :
* a1[i].equals(a2[i]). * a1[i].equals(a2[i]).
*/ */
public static boolean equals(Object[] a1, Object[] a2) { public static boolean equals(Object[]a1, Object[]a2)
{
// Quick test which saves comparing elements of the same array, and also // Quick test which saves comparing elements of the same array, and also
// catches the case that both are null. // catches the case that both are null.
if (a1 == a2) { if (a1 == a2)
return true; {
} return true;
try {
// If they're the same length, test each element
if (a1.length == a2.length) {
for (int i = 0; i < a1.length; i++) {
if (!(a1[i] == null ? a2[i] == null : a1[i].equals(a2[i]))) {
return false;
}
}
return true;
} }
try
{
// If they're the same length, test each element
if (a1.length == a2.length)
{
for (int i = 0; i < a1.length; i++)
{
if (!(a1[i] == null ? a2[i] == null : a1[i].equals(a2[i])))
{
return false;
}
}
return true;
}
// If a1 == null or a2 == null but not both then we will get a NullPointer // If a1 == null or a2 == null but not both then we will get a NullPointer
} catch (NullPointerException e) { }
} catch (NullPointerException e)
{
}
return false; return false;
} }
...@@ -656,7 +788,8 @@ public class Arrays { ...@@ -656,7 +788,8 @@ public class Arrays {
* @param a the array to fill * @param a the array to fill
* @param val the value to fill it with * @param val the value to fill it with
*/ */
public static void fill(boolean[] a, boolean val) { public static void fill(boolean[]a, boolean val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -671,11 +804,12 @@ public class Arrays { ...@@ -671,11 +804,12 @@ public class Arrays {
* @param toIndex the index to fill to, exclusive * @param toIndex the index to fill to, exclusive
* @param val the value to fill with * @param val the value to fill with
*/ */
public static void fill(boolean[] a, int fromIndex, int toIndex, public static void fill(boolean[]a, int fromIndex, int toIndex, boolean val)
boolean val) { {
for (int i = fromIndex; i < toIndex; i++) { for (int i = fromIndex; i < toIndex; i++)
a[i] = val; {
} a[i] = val;
}
} }
/** /**
...@@ -684,7 +818,8 @@ public class Arrays { ...@@ -684,7 +818,8 @@ public class Arrays {
* @param a the array to fill * @param a the array to fill
* @param val the value to fill it with * @param val the value to fill it with
*/ */
public static void fill(byte[] a, byte val) { public static void fill(byte[]a, byte val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -699,10 +834,12 @@ public class Arrays { ...@@ -699,10 +834,12 @@ public class Arrays {
* @param toIndex the index to fill to, exclusive * @param toIndex the index to fill to, exclusive
* @param val the value to fill with * @param val the value to fill with
*/ */
public static void fill(byte[] a, int fromIndex, int toIndex, byte val) { public static void fill(byte[]a, int fromIndex, int toIndex, byte val)
for (int i = fromIndex; i < toIndex; i++) { {
a[i] = val; for (int i = fromIndex; i < toIndex; i++)
} {
a[i] = val;
}
} }
/** /**
...@@ -711,7 +848,8 @@ public class Arrays { ...@@ -711,7 +848,8 @@ public class Arrays {
* @param a the array to fill * @param a the array to fill
* @param val the value to fill it with * @param val the value to fill it with
*/ */
public static void fill(char[] a, char val) { public static void fill(char[]a, char val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -726,10 +864,12 @@ public class Arrays { ...@@ -726,10 +864,12 @@ public class Arrays {
* @param toIndex the index to fill to, exclusive * @param toIndex the index to fill to, exclusive
* @param val the value to fill with * @param val the value to fill with
*/ */
public static void fill(char[] a, int fromIndex, int toIndex, char val) { public static void fill(char[]a, int fromIndex, int toIndex, char val)
for (int i = fromIndex; i < toIndex; i++) { {
a[i] = val; for (int i = fromIndex; i < toIndex; i++)
} {
a[i] = val;
}
} }
/** /**
...@@ -738,7 +878,8 @@ public class Arrays { ...@@ -738,7 +878,8 @@ public class Arrays {
* @param a the array to fill * @param a the array to fill
* @param val the value to fill it with * @param val the value to fill it with
*/ */
public static void fill(double[] a, double val) { public static void fill(double[]a, double val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -753,10 +894,12 @@ public class Arrays { ...@@ -753,10 +894,12 @@ public class Arrays {
* @param toIndex the index to fill to, exclusive * @param toIndex the index to fill to, exclusive
* @param val the value to fill with * @param val the value to fill with
*/ */
public static void fill(double[] a, int fromIndex, int toIndex, double val) { public static void fill(double[]a, int fromIndex, int toIndex, double val)
for (int i = fromIndex; i < toIndex; i++) { {
a[i] = val; for (int i = fromIndex; i < toIndex; i++)
} {
a[i] = val;
}
} }
/** /**
...@@ -765,7 +908,8 @@ public class Arrays { ...@@ -765,7 +908,8 @@ public class Arrays {
* @param a the array to fill * @param a the array to fill
* @param val the value to fill it with * @param val the value to fill it with
*/ */
public static void fill(float[] a, float val) { public static void fill(float[]a, float val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -780,10 +924,12 @@ public class Arrays { ...@@ -780,10 +924,12 @@ public class Arrays {
* @param toIndex the index to fill to, exclusive * @param toIndex the index to fill to, exclusive
* @param val the value to fill with * @param val the value to fill with
*/ */
public static void fill(float[] a, int fromIndex, int toIndex, float val) { public static void fill(float[]a, int fromIndex, int toIndex, float val)
for (int i = fromIndex; i < toIndex; i++) { {
a[i] = val; for (int i = fromIndex; i < toIndex; i++)
} {
a[i] = val;
}
} }
/** /**
...@@ -792,7 +938,8 @@ public class Arrays { ...@@ -792,7 +938,8 @@ public class Arrays {
* @param a the array to fill * @param a the array to fill
* @param val the value to fill it with * @param val the value to fill it with
*/ */
public static void fill(int[] a, int val) { public static void fill(int[]a, int val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -807,10 +954,12 @@ public class Arrays { ...@@ -807,10 +954,12 @@ public class Arrays {
* @param toIndex the index to fill to, exclusive * @param toIndex the index to fill to, exclusive
* @param val the value to fill with * @param val the value to fill with
*/ */
public static void fill(int[] a, int fromIndex, int toIndex, int val) { public static void fill(int[]a, int fromIndex, int toIndex, int val)
for (int i = fromIndex; i < toIndex; i++) { {
a[i] = val; for (int i = fromIndex; i < toIndex; i++)
} {
a[i] = val;
}
} }
/** /**
...@@ -819,7 +968,8 @@ public class Arrays { ...@@ -819,7 +968,8 @@ public class Arrays {
* @param a the array to fill * @param a the array to fill
* @param val the value to fill it with * @param val the value to fill it with
*/ */
public static void fill(long[] a, long val) { public static void fill(long[]a, long val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -834,10 +984,12 @@ public class Arrays { ...@@ -834,10 +984,12 @@ public class Arrays {
* @param toIndex the index to fill to, exclusive * @param toIndex the index to fill to, exclusive
* @param val the value to fill with * @param val the value to fill with
*/ */
public static void fill(long[] a, int fromIndex, int toIndex, long val) { public static void fill(long[]a, int fromIndex, int toIndex, long val)
for (int i = fromIndex; i < toIndex; i++) { {
a[i] = val; for (int i = fromIndex; i < toIndex; i++)
} {
a[i] = val;
}
} }
/** /**
...@@ -846,7 +998,8 @@ public class Arrays { ...@@ -846,7 +998,8 @@ public class Arrays {
* @param a the array to fill * @param a the array to fill
* @param val the value to fill it with * @param val the value to fill it with
*/ */
public static void fill(short[] a, short val) { public static void fill(short[]a, short val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -861,10 +1014,12 @@ public class Arrays { ...@@ -861,10 +1014,12 @@ public class Arrays {
* @param toIndex the index to fill to, exclusive * @param toIndex the index to fill to, exclusive
* @param val the value to fill with * @param val the value to fill with
*/ */
public static void fill(short[] a, int fromIndex, int toIndex, short val) { public static void fill(short[]a, int fromIndex, int toIndex, short val)
for (int i = fromIndex; i < toIndex; i++) { {
a[i] = val; for (int i = fromIndex; i < toIndex; i++)
} {
a[i] = val;
}
} }
/** /**
...@@ -875,7 +1030,8 @@ public class Arrays { ...@@ -875,7 +1030,8 @@ public class Arrays {
* @exception ClassCastException if val is not an instance of the element * @exception ClassCastException if val is not an instance of the element
* type of a. * type of a.
*/ */
public static void fill(Object[] a, Object val) { public static void fill(Object[]a, Object val)
{
// This implementation is slightly inefficient timewise, but the extra // This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code // effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped. // if it can be helped.
...@@ -892,10 +1048,12 @@ public class Arrays { ...@@ -892,10 +1048,12 @@ public class Arrays {
* @exception ClassCastException if val is not an instance of the element * @exception ClassCastException if val is not an instance of the element
* type of a. * type of a.
*/ */
public static void fill(Object[] a, int fromIndex, int toIndex, Object val) { public static void fill(Object[]a, int fromIndex, int toIndex, Object val)
for (int i = fromIndex; i < toIndex; i++) { {
a[i] = val; for (int i = fromIndex; i < toIndex; i++)
} {
a[i] = val;
}
} }
// Thanks to Paul Fisher <rao@gnu.org> for finding this quicksort algorithm // Thanks to Paul Fisher <rao@gnu.org> for finding this quicksort algorithm
...@@ -911,79 +1069,110 @@ public class Arrays { ...@@ -911,79 +1069,110 @@ public class Arrays {
* *
* @param a the array to sort * @param a the array to sort
*/ */
public static void sort(byte[] a) { public static void sort(byte[]a)
{
qsort(a, 0, a.length); qsort(a, 0, a.length);
} }
private static short cmp(byte i, byte j) { public static void sort(byte[] a, int fromIndex, int toIndex)
return (short)(i-j); {
qsort(a, fromIndex, toIndex);
} }
private static int med3(int a, int b, int c, byte[] d) { private static short cmp(byte i, byte j)
return cmp(d[a], d[b]) < 0 ? {
return (short) (i - j);
}
private static int med3(int a, int b, int c, byte[]d)
{
return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a) (cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
: (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a); : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
} }
private static void swap(int i, int j, byte[] a) { private static void swap(int i, int j, byte[]a)
{
byte c = a[i]; byte c = a[i];
a[i] = a[j]; a[i] = a[j];
a[j] = c; a[j] = c;
} }
private static void qsort(byte[] a, int start, int n) { private static void qsort(byte[]a, int start, int n)
{
// use an insertion sort on small arrays // use an insertion sort on small arrays
if (n < 7) { if (n < 7)
for (int i = start + 1; i < start + n; i++) {
for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--) for (int i = start + 1; i < start + n; i++)
swap(j, j-1, a); for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
return; swap(j, j - 1, a);
} return;
}
int pm = n/2; // small arrays, middle element
if (n > 7) {
int pl = start;
int pn = start + n-1;
if (n > 40) { // big arrays, pseudomedian of 9 int pm = n / 2; // small arrays, middle element
int s = n/8; if (n > 7)
pl = med3(pl, pl+s, pl+2*s, a); {
pm = med3(pm-s, pm, pm+s, a); int pl = start;
pn = med3(pn-2*s, pn-s, pn, a); int pn = start + n - 1;
if (n > 40)
{ // big arrays, pseudomedian of 9
int s = n / 8;
pl = med3(pl, pl + s, pl + 2 * s, a);
pm = med3(pm - s, pm, pm + s, a);
pn = med3(pn - 2 * s, pn - s, pn, a);
}
pm = med3(pl, pm, pn, a); // mid-size, med of 3
} }
pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
int pa, pb, pc, pd, pv; int pa, pb, pc, pd, pv;
short r; short r;
pv = start; swap(pv, pm, a); pv = start;
swap(pv, pm, a);
pa = pb = start; pa = pb = start;
pc = pd = start + n-1; pc = pd = start + n - 1;
for (;;) { for (;;)
while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) { {
if (r == 0) { swap(pa, pb, a); pa++; } while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
pb++; {
} if (r == 0)
while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) { {
if (r == 0) { swap(pc, pd, a); pd--; } swap(pa, pb, a);
pc--; pa++;
} }
if (pb > pc) break; pb++;
swap(pb, pc, a); }
pb++; while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
pc--; {
} if (r == 0)
{
swap(pc, pd, a);
pd--;
}
pc--;
}
if (pb > pc)
break;
swap(pb, pc, a);
pb++;
pc--;
}
int pn = start + n; int pn = start + n;
int s; int s;
s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a); s = Math.min(pa - start, pb - pa);
s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a); vecswap(start, pb - s, s, a);
if ((s = pb-pa) > 1) qsort(a, start, s); s = Math.min(pd - pc, pn - pd - 1);
if ((s = pd-pc) > 1) qsort(a, pn-s, s); vecswap(pb, pn - s, s, a);
if ((s = pb - pa) > 1)
qsort(a, start, s);
if ((s = pd - pc) > 1)
qsort(a, pn - s, s);
} }
private static void vecswap(int i, int j, int n, byte[] a) { private static void vecswap(int i, int j, int n, byte[]a)
{
for (; n > 0; i++, j++, n--) for (; n > 0; i++, j++, n--)
swap(i, j, a); swap(i, j, a);
} }
...@@ -998,79 +1187,110 @@ public class Arrays { ...@@ -998,79 +1187,110 @@ public class Arrays {
* *
* @param a the array to sort * @param a the array to sort
*/ */
public static void sort(char[] a) { public static void sort(char[]a)
{
qsort(a, 0, a.length); qsort(a, 0, a.length);
} }
private static int cmp(char i, char j) { public static void sort(char[] a, int fromIndex, int toIndex)
return i-j; {
qsort(a, fromIndex, toIndex);
}
private static int cmp(char i, char j)
{
return i - j;
} }
private static int med3(int a, int b, int c, char[] d) { private static int med3(int a, int b, int c, char[]d)
return cmp(d[a], d[b]) < 0 ? {
return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a) (cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
: (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a); : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
} }
private static void swap(int i, int j, char[] a) { private static void swap(int i, int j, char[]a)
{
char c = a[i]; char c = a[i];
a[i] = a[j]; a[i] = a[j];
a[j] = c; a[j] = c;
} }
private static void qsort(char[] a, int start, int n) { private static void qsort(char[]a, int start, int n)
{
// use an insertion sort on small arrays // use an insertion sort on small arrays
if (n < 7) { if (n < 7)
for (int i = start + 1; i < start + n; i++) {
for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--) for (int i = start + 1; i < start + n; i++)
swap(j, j-1, a); for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
return; swap(j, j - 1, a);
} return;
}
int pm = n/2; // small arrays, middle element
if (n > 7) {
int pl = start;
int pn = start + n-1;
if (n > 40) { // big arrays, pseudomedian of 9 int pm = n / 2; // small arrays, middle element
int s = n/8; if (n > 7)
pl = med3(pl, pl+s, pl+2*s, a); {
pm = med3(pm-s, pm, pm+s, a); int pl = start;
pn = med3(pn-2*s, pn-s, pn, a); int pn = start + n - 1;
if (n > 40)
{ // big arrays, pseudomedian of 9
int s = n / 8;
pl = med3(pl, pl + s, pl + 2 * s, a);
pm = med3(pm - s, pm, pm + s, a);
pn = med3(pn - 2 * s, pn - s, pn, a);
}
pm = med3(pl, pm, pn, a); // mid-size, med of 3
} }
pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
int pa, pb, pc, pd, pv; int pa, pb, pc, pd, pv;
int r; int r;
pv = start; swap(pv, pm, a); pv = start;
swap(pv, pm, a);
pa = pb = start; pa = pb = start;
pc = pd = start + n-1; pc = pd = start + n - 1;
for (;;) { for (;;)
while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) { {
if (r == 0) { swap(pa, pb, a); pa++; } while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
pb++; {
} if (r == 0)
while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) { {
if (r == 0) { swap(pc, pd, a); pd--; } swap(pa, pb, a);
pc--; pa++;
} }
if (pb > pc) break; pb++;
swap(pb, pc, a); }
pb++; while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
pc--; {
} if (r == 0)
{
swap(pc, pd, a);
pd--;
}
pc--;
}
if (pb > pc)
break;
swap(pb, pc, a);
pb++;
pc--;
}
int pn = start + n; int pn = start + n;
int s; int s;
s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a); s = Math.min(pa - start, pb - pa);
s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a); vecswap(start, pb - s, s, a);
if ((s = pb-pa) > 1) qsort(a, start, s); s = Math.min(pd - pc, pn - pd - 1);
if ((s = pd-pc) > 1) qsort(a, pn-s, s); vecswap(pb, pn - s, s, a);
if ((s = pb - pa) > 1)
qsort(a, start, s);
if ((s = pd - pc) > 1)
qsort(a, pn - s, s);
} }
private static void vecswap(int i, int j, int n, char[] a) { private static void vecswap(int i, int j, int n, char[]a)
{
for (; n > 0; i++, j++, n--) for (; n > 0; i++, j++, n--)
swap(i, j, a); swap(i, j, a);
} }
...@@ -1086,79 +1306,110 @@ public class Arrays { ...@@ -1086,79 +1306,110 @@ public class Arrays {
* *
* @param a the array to sort * @param a the array to sort
*/ */
public static void sort(double[] a) { public static void sort(double[]a)
{
qsort(a, 0, a.length); qsort(a, 0, a.length);
} }
private static double cmp(double i, double j) { public static void sort(double[] a, int fromIndex, int toIndex)
return i-j; {
qsort(a, fromIndex, toIndex);
} }
private static int med3(int a, int b, int c, double[] d) { private static double cmp(double i, double j)
return cmp(d[a], d[b]) < 0 ? {
return i - j;
}
private static int med3(int a, int b, int c, double[]d)
{
return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a) (cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
: (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a); : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
} }
private static void swap(int i, int j, double[] a) { private static void swap(int i, int j, double[]a)
{
double c = a[i]; double c = a[i];
a[i] = a[j]; a[i] = a[j];
a[j] = c; a[j] = c;
} }
private static void qsort(double[] a, int start, int n) { private static void qsort(double[]a, int start, int n)
{
// use an insertion sort on small arrays // use an insertion sort on small arrays
if (n < 7) { if (n < 7)
for (int i = start + 1; i < start + n; i++) {
for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--) for (int i = start + 1; i < start + n; i++)
swap(j, j-1, a); for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
return; swap(j, j - 1, a);
} return;
}
int pm = n/2; // small arrays, middle element
if (n > 7) {
int pl = start;
int pn = start + n-1;
if (n > 40) { // big arrays, pseudomedian of 9 int pm = n / 2; // small arrays, middle element
int s = n/8; if (n > 7)
pl = med3(pl, pl+s, pl+2*s, a); {
pm = med3(pm-s, pm, pm+s, a); int pl = start;
pn = med3(pn-2*s, pn-s, pn, a); int pn = start + n - 1;
if (n > 40)
{ // big arrays, pseudomedian of 9
int s = n / 8;
pl = med3(pl, pl + s, pl + 2 * s, a);
pm = med3(pm - s, pm, pm + s, a);
pn = med3(pn - 2 * s, pn - s, pn, a);
}
pm = med3(pl, pm, pn, a); // mid-size, med of 3
} }
pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
int pa, pb, pc, pd, pv; int pa, pb, pc, pd, pv;
double r; double r;
pv = start; swap(pv, pm, a); pv = start;
swap(pv, pm, a);
pa = pb = start; pa = pb = start;
pc = pd = start + n-1; pc = pd = start + n - 1;
for (;;) { for (;;)
while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) { {
if (r == 0) { swap(pa, pb, a); pa++; } while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
pb++; {
} if (r == 0)
while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) { {
if (r == 0) { swap(pc, pd, a); pd--; } swap(pa, pb, a);
pc--; pa++;
} }
if (pb > pc) break; pb++;
swap(pb, pc, a); }
pb++; while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
pc--; {
} if (r == 0)
{
swap(pc, pd, a);
pd--;
}
pc--;
}
if (pb > pc)
break;
swap(pb, pc, a);
pb++;
pc--;
}
int pn = start + n; int pn = start + n;
int s; int s;
s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a); s = Math.min(pa - start, pb - pa);
s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a); vecswap(start, pb - s, s, a);
if ((s = pb-pa) > 1) qsort(a, start, s); s = Math.min(pd - pc, pn - pd - 1);
if ((s = pd-pc) > 1) qsort(a, pn-s, s); vecswap(pb, pn - s, s, a);
if ((s = pb - pa) > 1)
qsort(a, start, s);
if ((s = pd - pc) > 1)
qsort(a, pn - s, s);
} }
private static void vecswap(int i, int j, int n, double[] a) { private static void vecswap(int i, int j, int n, double[]a)
{
for (; n > 0; i++, j++, n--) for (; n > 0; i++, j++, n--)
swap(i, j, a); swap(i, j, a);
} }
...@@ -1174,79 +1425,110 @@ public class Arrays { ...@@ -1174,79 +1425,110 @@ public class Arrays {
* *
* @param a the array to sort * @param a the array to sort
*/ */
public static void sort(float[] a) { public static void sort(float[]a)
{
qsort(a, 0, a.length); qsort(a, 0, a.length);
} }
private static float cmp(float i, float j) { public static void sort(float[] a, int fromIndex, int toIndex)
return i-j; {
qsort(a, fromIndex, toIndex);
}
private static float cmp(float i, float j)
{
return i - j;
} }
private static int med3(int a, int b, int c, float[] d) { private static int med3(int a, int b, int c, float[]d)
return cmp(d[a], d[b]) < 0 ? {
return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a) (cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
: (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a); : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
} }
private static void swap(int i, int j, float[] a) { private static void swap(int i, int j, float[]a)
{
float c = a[i]; float c = a[i];
a[i] = a[j]; a[i] = a[j];
a[j] = c; a[j] = c;
} }
private static void qsort(float[] a, int start, int n) { private static void qsort(float[]a, int start, int n)
{
// use an insertion sort on small arrays // use an insertion sort on small arrays
if (n < 7) { if (n < 7)
for (int i = start + 1; i < start + n; i++) {
for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--) for (int i = start + 1; i < start + n; i++)
swap(j, j-1, a); for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
return; swap(j, j - 1, a);
} return;
}
int pm = n/2; // small arrays, middle element
if (n > 7) {
int pl = start;
int pn = start + n-1;
if (n > 40) { // big arrays, pseudomedian of 9 int pm = n / 2; // small arrays, middle element
int s = n/8; if (n > 7)
pl = med3(pl, pl+s, pl+2*s, a); {
pm = med3(pm-s, pm, pm+s, a); int pl = start;
pn = med3(pn-2*s, pn-s, pn, a); int pn = start + n - 1;
if (n > 40)
{ // big arrays, pseudomedian of 9
int s = n / 8;
pl = med3(pl, pl + s, pl + 2 * s, a);
pm = med3(pm - s, pm, pm + s, a);
pn = med3(pn - 2 * s, pn - s, pn, a);
}
pm = med3(pl, pm, pn, a); // mid-size, med of 3
} }
pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
int pa, pb, pc, pd, pv; int pa, pb, pc, pd, pv;
float r; float r;
pv = start; swap(pv, pm, a); pv = start;
swap(pv, pm, a);
pa = pb = start; pa = pb = start;
pc = pd = start + n-1; pc = pd = start + n - 1;
for (;;) { for (;;)
while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) { {
if (r == 0) { swap(pa, pb, a); pa++; } while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
pb++; {
} if (r == 0)
while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) { {
if (r == 0) { swap(pc, pd, a); pd--; } swap(pa, pb, a);
pc--; pa++;
} }
if (pb > pc) break; pb++;
swap(pb, pc, a); }
pb++; while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
pc--; {
} if (r == 0)
{
swap(pc, pd, a);
pd--;
}
pc--;
}
if (pb > pc)
break;
swap(pb, pc, a);
pb++;
pc--;
}
int pn = start + n; int pn = start + n;
int s; int s;
s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a); s = Math.min(pa - start, pb - pa);
s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a); vecswap(start, pb - s, s, a);
if ((s = pb-pa) > 1) qsort(a, start, s); s = Math.min(pd - pc, pn - pd - 1);
if ((s = pd-pc) > 1) qsort(a, pn-s, s); vecswap(pb, pn - s, s, a);
if ((s = pb - pa) > 1)
qsort(a, start, s);
if ((s = pd - pc) > 1)
qsort(a, pn - s, s);
} }
private static void vecswap(int i, int j, int n, float[] a) { private static void vecswap(int i, int j, int n, float[]a)
{
for (; n > 0; i++, j++, n--) for (; n > 0; i++, j++, n--)
swap(i, j, a); swap(i, j, a);
} }
...@@ -1261,79 +1543,110 @@ public class Arrays { ...@@ -1261,79 +1543,110 @@ public class Arrays {
* *
* @param a the array to sort * @param a the array to sort
*/ */
public static void sort(int[] a) { public static void sort(int[]a)
{
qsort(a, 0, a.length); qsort(a, 0, a.length);
} }
private static long cmp(int i, int j) { public static void sort(int[] a, int fromIndex, int toIndex)
return (long)i-(long)j; {
qsort(a, fromIndex, toIndex);
}
private static long cmp(int i, int j)
{
return (long) i - (long) j;
} }
private static int med3(int a, int b, int c, int[] d) { private static int med3(int a, int b, int c, int[]d)
return cmp(d[a], d[b]) < 0 ? {
return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a) (cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
: (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a); : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
} }
private static void swap(int i, int j, int[] a) { private static void swap(int i, int j, int[]a)
{
int c = a[i]; int c = a[i];
a[i] = a[j]; a[i] = a[j];
a[j] = c; a[j] = c;
} }
private static void qsort(int[] a, int start, int n) { private static void qsort(int[]a, int start, int n)
{
// use an insertion sort on small arrays // use an insertion sort on small arrays
if (n < 7) { if (n < 7)
for (int i = start + 1; i < start + n; i++) {
for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--) for (int i = start + 1; i < start + n; i++)
swap(j, j-1, a); for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
return; swap(j, j - 1, a);
} return;
}
int pm = n/2; // small arrays, middle element
if (n > 7) {
int pl = start;
int pn = start + n-1;
if (n > 40) { // big arrays, pseudomedian of 9 int pm = n / 2; // small arrays, middle element
int s = n/8; if (n > 7)
pl = med3(pl, pl+s, pl+2*s, a); {
pm = med3(pm-s, pm, pm+s, a); int pl = start;
pn = med3(pn-2*s, pn-s, pn, a); int pn = start + n - 1;
if (n > 40)
{ // big arrays, pseudomedian of 9
int s = n / 8;
pl = med3(pl, pl + s, pl + 2 * s, a);
pm = med3(pm - s, pm, pm + s, a);
pn = med3(pn - 2 * s, pn - s, pn, a);
}
pm = med3(pl, pm, pn, a); // mid-size, med of 3
} }
pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
int pa, pb, pc, pd, pv; int pa, pb, pc, pd, pv;
long r; long r;
pv = start; swap(pv, pm, a); pv = start;
swap(pv, pm, a);
pa = pb = start; pa = pb = start;
pc = pd = start + n-1; pc = pd = start + n - 1;
for (;;) { for (;;)
while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) { {
if (r == 0) { swap(pa, pb, a); pa++; } while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
pb++; {
} if (r == 0)
while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) { {
if (r == 0) { swap(pc, pd, a); pd--; } swap(pa, pb, a);
pc--; pa++;
} }
if (pb > pc) break; pb++;
swap(pb, pc, a); }
pb++; while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
pc--; {
} if (r == 0)
{
swap(pc, pd, a);
pd--;
}
pc--;
}
if (pb > pc)
break;
swap(pb, pc, a);
pb++;
pc--;
}
int pn = start + n; int pn = start + n;
int s; int s;
s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a); s = Math.min(pa - start, pb - pa);
s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a); vecswap(start, pb - s, s, a);
if ((s = pb-pa) > 1) qsort(a, start, s); s = Math.min(pd - pc, pn - pd - 1);
if ((s = pd-pc) > 1) qsort(a, pn-s, s); vecswap(pb, pn - s, s, a);
if ((s = pb - pa) > 1)
qsort(a, start, s);
if ((s = pd - pc) > 1)
qsort(a, pn - s, s);
} }
private static void vecswap(int i, int j, int n, int[] a) { private static void vecswap(int i, int j, int n, int[]a)
{
for (; n > 0; i++, j++, n--) for (; n > 0; i++, j++, n--)
swap(i, j, a); swap(i, j, a);
} }
...@@ -1348,80 +1661,110 @@ public class Arrays { ...@@ -1348,80 +1661,110 @@ public class Arrays {
* *
* @param a the array to sort * @param a the array to sort
*/ */
public static void sort(long[] a) { public static void sort(long[]a)
{
qsort(a, 0, a.length); qsort(a, 0, a.length);
} }
public static void sort(long[] a, int fromIndex, int toIndex)
{
qsort(a, fromIndex, toIndex);
}
// The "cmp" method has been removed from here and replaced with direct // The "cmp" method has been removed from here and replaced with direct
// compares in situ, to avoid problems with overflow if the difference // compares in situ, to avoid problems with overflow if the difference
// between two numbers is bigger than a long will hold. // between two numbers is bigger than a long will hold.
// One particular change as a result is the use of r1 and r2 in qsort // One particular change as a result is the use of r1 and r2 in qsort
private static int med3(int a, int b, int c, long[] d) { private static int med3(int a, int b, int c, long[]d)
return d[a] < d[b] ? {
return d[a] < d[b] ?
(d[b] < d[c] ? b : d[a] < d[c] ? c : a) (d[b] < d[c] ? b : d[a] < d[c] ? c : a)
: (d[b] > d[c] ? b : d[a] > d[c] ? c : a); : (d[b] > d[c] ? b : d[a] > d[c] ? c : a);
} }
private static void swap(int i, int j, long[] a) { private static void swap(int i, int j, long[]a)
{
long c = a[i]; long c = a[i];
a[i] = a[j]; a[i] = a[j];
a[j] = c; a[j] = c;
} }
private static void qsort(long[] a, int start, int n) { private static void qsort(long[]a, int start, int n)
{
// use an insertion sort on small arrays // use an insertion sort on small arrays
if (n < 7) { if (n < 7)
for (int i = start + 1; i < start + n; i++) {
for (int j = i; j > 0 && a[j-1] > a[j]; j--) for (int i = start + 1; i < start + n; i++)
swap(j, j-1, a); for (int j = i; j > 0 && a[j - 1] > a[j]; j--)
return; swap(j, j - 1, a);
} return;
}
int pm = n/2; // small arrays, middle element
if (n > 7) {
int pl = start;
int pn = start + n-1;
if (n > 40) { // big arrays, pseudomedian of 9 int pm = n / 2; // small arrays, middle element
int s = n/8; if (n > 7)
pl = med3(pl, pl+s, pl+2*s, a); {
pm = med3(pm-s, pm, pm+s, a); int pl = start;
pn = med3(pn-2*s, pn-s, pn, a); int pn = start + n - 1;
if (n > 40)
{ // big arrays, pseudomedian of 9
int s = n / 8;
pl = med3(pl, pl + s, pl + 2 * s, a);
pm = med3(pm - s, pm, pm + s, a);
pn = med3(pn - 2 * s, pn - s, pn, a);
}
pm = med3(pl, pm, pn, a); // mid-size, med of 3
} }
pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
int pa, pb, pc, pd, pv; int pa, pb, pc, pd, pv;
long r1, r2; long r1, r2;
pv = start; swap(pv, pm, a); pv = start;
swap(pv, pm, a);
pa = pb = start; pa = pb = start;
pc = pd = start + n-1; pc = pd = start + n - 1;
for (;;) { for (;;)
while (pb <= pc && (r1 = a[pb]) <= (r2 = a[pv])) { {
if (r1 == r2) { swap(pa, pb, a); pa++; } while (pb <= pc && (r1 = a[pb]) <= (r2 = a[pv]))
pb++; {
} if (r1 == r2)
while (pc >= pb && (r1 = a[pc]) >= (r2 = a[pv])) { {
if (r1 == r2) { swap(pc, pd, a); pd--; } swap(pa, pb, a);
pc--; pa++;
} }
if (pb > pc) break; pb++;
swap(pb, pc, a); }
pb++; while (pc >= pb && (r1 = a[pc]) >= (r2 = a[pv]))
pc--; {
} if (r1 == r2)
{
swap(pc, pd, a);
pd--;
}
pc--;
}
if (pb > pc)
break;
swap(pb, pc, a);
pb++;
pc--;
}
int pn = start + n; int pn = start + n;
int s; int s;
s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a); s = Math.min(pa - start, pb - pa);
s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a); vecswap(start, pb - s, s, a);
if ((s = pb-pa) > 1) qsort(a, start, s); s = Math.min(pd - pc, pn - pd - 1);
if ((s = pd-pc) > 1) qsort(a, pn-s, s); vecswap(pb, pn - s, s, a);
if ((s = pb - pa) > 1)
qsort(a, start, s);
if ((s = pd - pc) > 1)
qsort(a, pn - s, s);
} }
private static void vecswap(int i, int j, int n, long[] a) { private static void vecswap(int i, int j, int n, long[]a)
{
for (; n > 0; i++, j++, n--) for (; n > 0; i++, j++, n--)
swap(i, j, a); swap(i, j, a);
} }
...@@ -1436,79 +1779,110 @@ public class Arrays { ...@@ -1436,79 +1779,110 @@ public class Arrays {
* *
* @param a the array to sort * @param a the array to sort
*/ */
public static void sort(short[] a) { public static void sort(short[]a)
{
qsort(a, 0, a.length); qsort(a, 0, a.length);
} }
private static int cmp(short i, short j) { public static void sort(short[] a, int fromIndex, int toIndex)
return i-j; {
qsort(a, fromIndex, toIndex);
} }
private static int med3(int a, int b, int c, short[] d) { private static int cmp(short i, short j)
return cmp(d[a], d[b]) < 0 ? {
return i - j;
}
private static int med3(int a, int b, int c, short[]d)
{
return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a) (cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
: (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a); : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
} }
private static void swap(int i, int j, short[] a) { private static void swap(int i, int j, short[]a)
{
short c = a[i]; short c = a[i];
a[i] = a[j]; a[i] = a[j];
a[j] = c; a[j] = c;
} }
private static void qsort(short[] a, int start, int n) { private static void qsort(short[]a, int start, int n)
{
// use an insertion sort on small arrays // use an insertion sort on small arrays
if (n < 7) { if (n < 7)
for (int i = start + 1; i < start + n; i++) {
for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--) for (int i = start + 1; i < start + n; i++)
swap(j, j-1, a); for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
return; swap(j, j - 1, a);
} return;
}
int pm = n/2; // small arrays, middle element
if (n > 7) {
int pl = start;
int pn = start + n-1;
if (n > 40) { // big arrays, pseudomedian of 9 int pm = n / 2; // small arrays, middle element
int s = n/8; if (n > 7)
pl = med3(pl, pl+s, pl+2*s, a); {
pm = med3(pm-s, pm, pm+s, a); int pl = start;
pn = med3(pn-2*s, pn-s, pn, a); int pn = start + n - 1;
if (n > 40)
{ // big arrays, pseudomedian of 9
int s = n / 8;
pl = med3(pl, pl + s, pl + 2 * s, a);
pm = med3(pm - s, pm, pm + s, a);
pn = med3(pn - 2 * s, pn - s, pn, a);
}
pm = med3(pl, pm, pn, a); // mid-size, med of 3
} }
pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
int pa, pb, pc, pd, pv; int pa, pb, pc, pd, pv;
int r; int r;
pv = start; swap(pv, pm, a); pv = start;
swap(pv, pm, a);
pa = pb = start; pa = pb = start;
pc = pd = start + n-1; pc = pd = start + n - 1;
for (;;) { for (;;)
while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) { {
if (r == 0) { swap(pa, pb, a); pa++; } while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
pb++; {
} if (r == 0)
while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) { {
if (r == 0) { swap(pc, pd, a); pd--; } swap(pa, pb, a);
pc--; pa++;
} }
if (pb > pc) break; pb++;
swap(pb, pc, a); }
pb++; while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
pc--; {
} if (r == 0)
{
swap(pc, pd, a);
pd--;
}
pc--;
}
if (pb > pc)
break;
swap(pb, pc, a);
pb++;
pc--;
}
int pn = start + n; int pn = start + n;
int s; int s;
s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a); s = Math.min(pa - start, pb - pa);
s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a); vecswap(start, pb - s, s, a);
if ((s = pb-pa) > 1) qsort(a, start, s); s = Math.min(pd - pc, pn - pd - 1);
if ((s = pd-pc) > 1) qsort(a, pn-s, s); vecswap(pb, pn - s, s, a);
if ((s = pb - pa) > 1)
qsort(a, start, s);
if ((s = pd - pc) > 1)
qsort(a, pn - s, s);
} }
private static void vecswap(int i, int j, int n, short[] a) { private static void vecswap(int i, int j, int n, short[]a)
{
for (; n > 0; i++, j++, n--) for (; n > 0; i++, j++, n--)
swap(i, j, a); swap(i, j, a);
} }
...@@ -1520,45 +1894,45 @@ public class Arrays { ...@@ -1520,45 +1894,45 @@ public class Arrays {
* than I can, and if I try it will make it more confusing for the * than I can, and if I try it will make it more confusing for the
* JIT. * JIT.
*/ */
private static void mergeSort(Object[] a, int from, int to, Comparator c) private static void mergeSort(Object[]a, int from, int to, Comparator c)
{ {
// First presort the array in chunks of length 6 with insertion sort. // First presort the array in chunks of length 6 with insertion sort.
// mergesort would give too much overhead for this length. // mergesort would give too much overhead for this length.
for (int chunk = from; chunk < to; chunk += 6) for (int chunk = from; chunk < to; chunk += 6)
{ {
int end = Math.min(chunk+6, to); int end = Math.min(chunk + 6, to);
for (int i = chunk + 1; i < end; i++) for (int i = chunk + 1; i < end; i++)
{ {
if (c.compare(a[i-1], a[i]) > 0) if (c.compare(a[i - 1], a[i]) > 0)
{ {
// not already sorted // not already sorted
int j=i; int j = i;
Object elem = a[j]; Object elem = a[j];
do do
{ {
a[j] = a[j-1]; a[j] = a[j - 1];
j--; j--;
} }
while (j>chunk && c.compare(a[j-1], elem) > 0); while (j > chunk && c.compare(a[j - 1], elem) > 0);
a[j] = elem; a[j] = elem;
} }
} }
} }
int len = to - from; int len = to - from;
// If length is smaller or equal 6 we are done. // If length is smaller or equal 6 we are done.
if (len <= 6) if (len <= 6)
return; return;
Object[] src = a; Object[]src = a;
Object[] dest = new Object[len]; Object[]dest = new Object[len];
Object[] t = null; // t is used for swapping src and dest Object[]t = null; // t is used for swapping src and dest
// The difference of the fromIndex of the src and dest array. // The difference of the fromIndex of the src and dest array.
int srcDestDiff = -from; int srcDestDiff = -from;
// The merges are done in this loop // The merges are done in this loop
for (int size = 6; size < len; size <<= 1) for (int size = 6; size < len; size <<= 1)
{ {
for (int start = from; start < to; start += size << 1) for (int start = from; start < to; start += size << 1)
{ {
...@@ -1566,48 +1940,55 @@ public class Arrays { ...@@ -1566,48 +1940,55 @@ public class Arrays {
// end the start of the next sublist (or end of array). // end the start of the next sublist (or end of array).
int mid = start + size; int mid = start + size;
int end = Math.min(to, mid + size); int end = Math.min(to, mid + size);
// The second list is empty or the elements are already in // The second list is empty or the elements are already in
// order - no need to merge // order - no need to merge
if (mid >= end || c.compare(src[mid - 1], src[mid]) <= 0) { if (mid >= end || c.compare(src[mid - 1], src[mid]) <= 0)
System.arraycopy(src, start, {
dest, start + srcDestDiff, end - start); System.arraycopy(src, start,
dest, start + srcDestDiff, end - start);
// The two halves just need swapping - no need to merge
} else if (c.compare(src[start], src[end - 1]) > 0) { // The two halves just need swapping - no need to merge
System.arraycopy(src, start, }
dest, end - size + srcDestDiff, size); else if (c.compare(src[start], src[end - 1]) > 0)
System.arraycopy(src, mid, {
dest, start + srcDestDiff, end - mid); System.arraycopy(src, start,
dest, end - size + srcDestDiff, size);
} else { System.arraycopy(src, mid,
// Declare a lot of variables to save repeating dest, start + srcDestDiff, end - mid);
// calculations. Hopefully a decent JIT will put these
// in registers and make this fast }
int p1 = start; else
int p2 = mid; {
int i = start + srcDestDiff; // Declare a lot of variables to save repeating
// calculations. Hopefully a decent JIT will put these
// The main merge loop; terminates as soon as either // in registers and make this fast
// half is ended int p1 = start;
while (p1 < mid && p2 < end) int p2 = mid;
{ int i = start + srcDestDiff;
dest[i++] =
src[c.compare(src[p1], src[p2]) <= 0 ? p1++ : p2++]; // The main merge loop; terminates as soon as either
} // half is ended
while (p1 < mid && p2 < end)
// Finish up by copying the remainder of whichever half {
// wasn't finished. dest[i++] =
if (p1 < mid) src[c.compare(src[p1], src[p2]) <= 0 ? p1++ : p2++];
System.arraycopy(src, p1, dest, i, mid - p1); }
else
System.arraycopy(src, p2, dest, i, end - p2); // Finish up by copying the remainder of whichever half
} // wasn't finished.
if (p1 < mid)
System.arraycopy(src, p1, dest, i, mid - p1);
else
System.arraycopy(src, p2, dest, i, end - p2);
}
} }
// swap src and dest ready for the next merge // swap src and dest ready for the next merge
t = src; src = dest; dest = t; t = src;
src = dest;
dest = t;
from += srcDestDiff; from += srcDestDiff;
to += srcDestDiff; to += srcDestDiff;
srcDestDiff = -srcDestDiff; srcDestDiff = -srcDestDiff;
} }
...@@ -1635,7 +2016,8 @@ public class Arrays { ...@@ -1635,7 +2016,8 @@ public class Arrays {
* @exception NullPointerException if an element is null (since * @exception NullPointerException if an element is null (since
* null.compareTo cannot work) * null.compareTo cannot work)
*/ */
public static void sort(Object[] a) { public static void sort(Object[]a)
{
mergeSort(a, 0, a.length, defaultComparator); mergeSort(a, 0, a.length, defaultComparator);
} }
...@@ -1652,7 +2034,8 @@ public class Arrays { ...@@ -1652,7 +2034,8 @@ public class Arrays {
* @exception ClassCastException if any two elements are not mutually * @exception ClassCastException if any two elements are not mutually
* comparable by the Comparator provided * comparable by the Comparator provided
*/ */
public static void sort(Object[] a, Comparator c) { public static void sort(Object[]a, Comparator c)
{
mergeSort(a, 0, a.length, c); mergeSort(a, 0, a.length, c);
} }
...@@ -1673,11 +2056,11 @@ public class Arrays { ...@@ -1673,11 +2056,11 @@ public class Arrays {
* are not in range. * are not in range.
* @exception IllegalArgumentException if fromIndex > toIndex * @exception IllegalArgumentException if fromIndex > toIndex
*/ */
public static void sort(Object[] a, int fromIndex, public static void sort(Object[]a, int fromIndex, int toIndex)
int toIndex) { {
if (fromIndex > toIndex) if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex "+fromIndex throw new IllegalArgumentException("fromIndex " + fromIndex
+" > toIndex "+toIndex); + " > toIndex " + toIndex);
mergeSort(a, fromIndex, toIndex, defaultComparator); mergeSort(a, fromIndex, toIndex, defaultComparator);
} }
...@@ -1699,11 +2082,11 @@ public class Arrays { ...@@ -1699,11 +2082,11 @@ public class Arrays {
* are not in range. * are not in range.
* @exception IllegalArgumentException if fromIndex > toIndex * @exception IllegalArgumentException if fromIndex > toIndex
*/ */
public static void sort(Object[] a, int fromIndex, public static void sort(Object[]a, int fromIndex, int toIndex, Comparator c)
int toIndex, Comparator c) { {
if (fromIndex > toIndex) if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex "+fromIndex throw new IllegalArgumentException("fromIndex " + fromIndex
+" > toIndex "+toIndex); + " > toIndex " + toIndex);
mergeSort(a, fromIndex, toIndex, c); mergeSort(a, fromIndex, toIndex, c);
} }
...@@ -1715,13 +2098,14 @@ public class Arrays { ...@@ -1715,13 +2098,14 @@ public class Arrays {
* @param a the array to return a view of * @param a the array to return a view of
* @returns a fixed-size list, changes to which "write through" to the array * @returns a fixed-size list, changes to which "write through" to the array
*/ */
public static List asList(final Object[] a) { public static List asList(final Object[]a)
{
if (a == null) { if (a == null)
throw new NullPointerException(); {
} throw new NullPointerException();
}
return new ListImpl( a ); return new ListImpl(a);
} }
...@@ -1731,21 +2115,25 @@ public class Arrays { ...@@ -1731,21 +2115,25 @@ public class Arrays {
* Note: When Sun fully specify serialized forms, this class will have to * Note: When Sun fully specify serialized forms, this class will have to
* be renamed. * be renamed.
*/ */
private static class ListImpl extends AbstractList { private static class ListImpl extends AbstractList
{
ListImpl(Object[] a) { ListImpl(Object[]a)
{
this.a = a; this.a = a;
} }
public Object get(int index) { public Object get(int index)
{
return a[index]; return a[index];
} }
public int size() { public int size()
{
return a.length; return a.length;
} }
public Object set(int index, Object element) { public Object set(int index, Object element)
{
Object old = a[index]; Object old = a[index];
a[index] = element; a[index] = element;
return old; return old;
...@@ -1753,5 +2141,4 @@ public class Arrays { ...@@ -1753,5 +2141,4 @@ public class Arrays {
private Object[] a; private Object[] a;
} }
} }
libjava/scripts/blocks.pl 0 → 100644
#! /usr/bin/perl
if ($ARGV[0] eq '')
{
$file = 'Blocks.txt';
if (! -f $file)
{
# Too painful to figure out how to get Perl to do it.
# FIXME.
system 'wget -o .wget-log http://www.isi.edu/in-notes/iana/unidata/Blocks.txt';
}
}
else
{
$file = $ARGV[0];
}
open (INPUT, "< $file") || die "couldn't open $file: $!";
@array = ();
while (<INPUT>)
{
next if /^#/;
chop;
($start, $to, $text) = split (/; /);
($symbol = $text) =~ tr/a-z/A-Z/;
$symbol =~ s/[- ]/_/g;
# Special case for one of the SPECIALS.
next if $start eq 'FEFF';
printf " public static final UnicodeBlock %s = new UnicodeBlock (\"%s\", '\\u%s', '\\u%s');\n",
$symbol, $text, $start, $to;
push (@array, $symbol);
}
printf " private static final UnicodeBlock[] blocks = {\n";
foreach (@array)
{
printf " %s", $_;
printf "," unless $_ eq 'SPECIALS';
printf "\n";
}
printf " };\n";
close (INPUT);
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment