From a74db3c1dc5761d5c2f9b3e52a543ae733b91baa Mon Sep 17 00:00:00 2001 From: jjenista Date: Wed, 18 Feb 2009 22:20:32 +0000 Subject: [PATCH] updating mlp benchmarks, extending class library --- .../getpot-java/mergeExamples/Example.java | 114 ++-- .../mlp/getpot-java/mergeExamples/GetPot.java | 9 +- .../mlp/getpot-java/mergeExamples/makefile | 2 +- Robust/src/ClassLibrary/Hashtable.java | 14 + Robust/src/ClassLibrary/Vector.java | 27 +- Robust/src/ClassLibrary/gnu/Double.java | 630 ++++++++++++++++++ Robust/src/ClassLibrary/gnu/Number.java | 163 +++++ 7 files changed, 901 insertions(+), 58 deletions(-) create mode 100644 Robust/src/ClassLibrary/Hashtable.java create mode 100644 Robust/src/ClassLibrary/gnu/Double.java create mode 100644 Robust/src/ClassLibrary/gnu/Number.java diff --git a/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/Example.java b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/Example.java index 637611ec..ecc3f57f 100644 --- a/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/Example.java +++ b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/Example.java @@ -6,8 +6,16 @@ public class Example { public static void main(String args []) { - - GetPot cl = disjoint gp1 new GetPot(args, "Flags"); + String[] args1 = new String[7]; + args1[0] = "program"; + args1[1] = "-yox"; + args1[2] = "-nxj"; + args1[3] = "-dude"; + args1[4] = "-fernb"; + args1[5] = "--ok"; + args1[6] = "gibberish"; + + GetPot cl = disjoint gp1 new GetPot(args1, "Flags"); if( cl.size() == 1 || cl.search("--help", "-h") ) print_help(); // does first argument contain 'x', 'X', 'c', 'C', 'k', or 'K' ? @@ -17,13 +25,19 @@ public class Example { // is there any option starting with '-' containing 'a', 'b', or 'c' ? boolean abc_f = cl.options_contain("abc"); - System.printString("first flag = " + first_f); - System.printString("second flag = " + second_f); - System.printString("a, b, or c found = " + abc_f ); + System.printString("first flag = " + first_f+"\n"); + System.printString("second flag = " + second_f+"\n"); + System.printString("a, b, or c found = " + abc_f+"\n"); + String[] args2 = new String[5]; + args2[0] = "program"; + args2[1] = "-V"; + args2[2] = "-9.81"; + args2[3] = "-U"; + args2[4] = "-Heinz"; - cl = disjoint gp2 new GetPot(args, "DirectFollow"); + cl = disjoint gp2 new GetPot(args2, "DirectFollow"); if( cl.size() == 1 || cl.search("--help", "-h") ) print_help("DirectFollow"); @@ -57,9 +71,14 @@ public class Example { + String[] args3 = new String[5]; + args3[0] = "program"; + args3[1] = "-gjhx"; + args3[2] = "--rudimental"; + args3[3] = "guy"; + args3[4] = "dude"; - - cl = disjoint gp3 new GetPot(args, "Filter"); + cl = disjoint gp3 new GetPot(args3, "Filter"); GetPot ifpot = disjoint gp4 new GetPot("example.pot"); // (1) search for multiple options with the same meaning @@ -81,46 +100,46 @@ public class Example { // of the argument inside the namespace given by prefix ifpot.set_prefix("group/"); - System.printString(" -- flags in options / arguments"); + System.printString(" -- flags in options / arguments"+"\n"); first_f = ifpot.argument_contains(1, "xX"); second_f = ifpot.argument_contains(1, "cCkK"); abc_f = ifpot.options_contain("abc"); - System.printString(" Flags in first argument in [flags]\n"); - System.printString(" x or X in arg 1 = " + first_f); - System.printString(" c, C, k or K in arg 1 = " + second_f); - System.printString(" a,b, or c in options = " + abc_f); - System.printString(""); - System.printString(" -- search(), next() and follow()"); - System.printString(""); - System.printString(" found \"--rudimental\" = " + ifpot.search("--rudimental")); + System.printString(" Flags in first argument in [flags]\n"+"\n"); + System.printString(" x or X in arg 1 = " + first_f+"\n"); + System.printString(" c, C, k or K in arg 1 = " + second_f+"\n"); + System.printString(" a,b, or c in options = " + abc_f+"\n"); + System.printString(""+"\n"); + System.printString(" -- search(), next() and follow()"+"\n"); + System.printString(""+"\n"); + System.printString(" found \"--rudimental\" = " + ifpot.search("--rudimental")+"\n"); int Tmp1 = ifpot.next(-1); int Tmp2 = ifpot.next(-1); - System.printString(" followed by " + Tmp1 + " " + Tmp2); + System.printString(" followed by " + Tmp1 + " " + Tmp2+"\n"); String Tmp3 = ifpot.follow("nothing", "--rudimental"); int Tmp4 = ifpot.next(-1); - System.printString(" rudimental = " + Tmp3 + ", " + Tmp4 + "\n"); + System.printString(" rudimental = " + Tmp3 + ", " + Tmp4 + "\n"+"\n"); // -- variables - System.printString(""); - System.printString(" -- variables in section [user-variables]"); - System.printString(""); + System.printString(""+"\n"); + System.printString(" -- variables in section [user-variables]"+"\n"); + System.printString(""+"\n"); ifpot.set_prefix("user-variables/"); String variable_names[] = ifpot.get_variable_names(); for(int i=0; i < variable_names.length ; i++) { String name = variable_names[i]; - System.printString(" " + name + " \t= "); - System.printString(""+ifpot.call(name, 1e37, 0)); - System.printString("[" + ifpot.call(name, "[1]", 1) + "]\n"); + System.printString(" " + name + " \t= "+"\n"); + System.printString(""+ifpot.call(name, 1e37, 0)+"\n"); + System.printString("[" + ifpot.call(name, "[1]", 1) + "]\n"+"\n"); } - System.printString(""); + System.printString(""+"\n"); // -- pseudo function calls if( cl.search("--nice") ) { - System.printString(" -- pseudo function call feature"); - System.printString(""); + System.printString(" -- pseudo function call feature"+"\n"); + System.printString(""+"\n"); ifpot.set_prefix("pseudo-function-calls/"); ifpot.init_multiple_occurrence(); @@ -166,17 +185,15 @@ public class Example { } } else { - System.printString("(use the --nice command line flag for graphical output)"); + System.printString("(use the --nice command line flag for graphical output)"+"\n"); } - System.printString(""); - - + System.printString(""+"\n"); - cl = disjoint gp5 new GetPot(args, "Get"); + cl = disjoint gp5 new GetPot(args1, "Get"); ifpot = disjoint gp6 new GetPot("expand.pot"); if( cl.search("--internal-information", "-i") ) { @@ -292,7 +309,7 @@ public class Example { - cl = disjoint gp7 new GetPot(args, "Follow"); + cl = disjoint gp7 new GetPot(args1, "Follow"); // to function 'cl.search(..)' if( cl.search("--help", "-h", "--hilfe") ) @@ -323,7 +340,7 @@ public class Example { - cl = disjoint gp8 new GetPot(args, "Get"); + cl = disjoint gp8 new GetPot(args1, "Get"); // GetPot Java can treat upto 6 strings, then it needs a String[] if( cl.search("--help", "-h", "--hilfe", "--sos", "--about", "--what-is") ) { @@ -356,9 +373,10 @@ public class Example { + System.exit(-1); - - cl = disjoint gp9 new GetPot(args, "InputFile"); + + cl = disjoint gp9 new GetPot(args1, "InputFile"); GetPot ifile = disjoint gp10 new GetPot("example.pot"); if( cl.size() == 1 || cl.search("--help", "-h") ) @@ -405,6 +423,7 @@ public class Example { if( n_f ) { nfl = "activated"; } else { nfl = "disabled"; } System.printString("nonsense-flag = " + nfl); + @@ -412,8 +431,7 @@ public class Example { - - cl = disjoint gp11 new GetPot(args, "Next"); + cl = disjoint gp11 new GetPot(args1, "Next"); // all the following pain, only to pass a string array // to function 'cl.search(..)' @@ -436,7 +454,7 @@ public class Example { - cl = disjoint gp12 new GetPot(args, "Nominus"); + cl = disjoint gp12 new GetPot(args1, "Nominus"); // if( cl.size() == 1 || cl.search("--help", "-h") ) print_help(); @@ -458,7 +476,7 @@ public class Example { - cl = disjoint gp13 new GetPot(args, "Options"); + cl = disjoint gp13 new GetPot(args1, "Options"); // (1) search for a single option // ------------------------------- @@ -490,7 +508,7 @@ public class Example { - cl = disjoint gp14 new GetPot(args, "Ufo"); + cl = disjoint gp14 new GetPot(args1, "Ufo"); String[] ufos = new String[1]; if( cl.search("-h", "--help") ) { @@ -596,7 +614,7 @@ public class Example { - cl = disjoint gp16 new GetPot(args, "Variables"); + cl = disjoint gp16 new GetPot(args1, "Variables"); if( cl.size() == 1 || cl.search("--help", "-h") ) print_help("java Variables"); if( cl.search("--internal-information", "-i") ) { @@ -638,9 +656,9 @@ public class Example { static void something(String User, String User2, String User3, double Value, double Value2, double Value3, int Number, int Number2, int Number3) { - System.printString("Users = " + User + ", " + User2 + ", " + User3); - System.printString("Values = " + Value + ", " + Value2 + ", " + Value3); - System.printString("Numbers = " + Number + ", " + Number2 + ", " + Number3); + System.printString("Users = " + User + ", " + User2 + ", " + User3+"\n"); + System.printString("Values = " + Value + ", " + Value2 + ", " + Value3+"\n"); + System.printString("Numbers = " + Number + ", " + Number2 + ", " + Number3+"\n"); } @@ -648,12 +666,12 @@ public class Example { static void print_help() { - System.printString("help!"); + System.printString("help!\n"); System.exit(0); } static void print_help(String s) { - System.printString("help!"); + System.printString("help!\n"); System.exit(0); } } diff --git a/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/GetPot.java b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/GetPot.java index e0571417..c64eb9b3 100755 --- a/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/GetPot.java +++ b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/GetPot.java @@ -74,6 +74,12 @@ public class GetPot { __argv.addElement(copied_str); } + + for(int i=0; i < __argv.size(); i++) { + System.printString(__argv.elementAt(i)+"\n"); + } + + argv = new Vector(); __argv.insertElementAt(applicationName, 0); __parse_argument_vector(__argv); @@ -257,12 +263,13 @@ public class GetPot { int tmp0 = 0; int tmp = 0; int last_letter = 0; + while(1+1 == 2) { last_letter = tmp; tmp0 = istr.read(); tmp = tmp0; if( tmp == -1 || ((tmp == ' ' || tmp == '\t' || tmp == '\n') && last_letter != '\\') ) { return token; - } + } else if( tmp == '\'' && last_letter != '\\' ) { // QUOTES: un-backslashed quotes => it's a string token += __get_string(istr); diff --git a/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/makefile b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/makefile index 9b069e5f..49a63f4d 100644 --- a/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/makefile +++ b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/makefile @@ -4,7 +4,7 @@ PROGRAM=test SOURCE_FILES=*.java BUILDSCRIPT=~/research/Robust/src/buildscript -BSFLAGS= -mainclass $(MAIN_CLASS) -justanalyze -ownership -ownallocdepth 1 -ownwritedots final -enable-assertions +BSFLAGS= -mainclass $(MAIN_CLASS) #-justanalyze -ownership -ownallocdepth 1 -ownwritedots final -enable-assertions all: $(PROGRAM).bin diff --git a/Robust/src/ClassLibrary/Hashtable.java b/Robust/src/ClassLibrary/Hashtable.java new file mode 100644 index 00000000..a8043524 --- /dev/null +++ b/Robust/src/ClassLibrary/Hashtable.java @@ -0,0 +1,14 @@ +public class Hashtable extends HashMap +{ + public Hashtable() { + HashMap(16, 0.75f); + } + + public Hashtable(int initialCapacity) { + HashMap(initialCapacity, 0.75f); + } + + public Hashtable(int initialCapacity, float loadFactor) { + HashMap(initialCapacity, loadFactor); + } +} diff --git a/Robust/src/ClassLibrary/Vector.java b/Robust/src/ClassLibrary/Vector.java index fb916cfc..2cb0a8fc 100644 --- a/Robust/src/ClassLibrary/Vector.java +++ b/Robust/src/ClassLibrary/Vector.java @@ -28,17 +28,22 @@ public class Vector { public Object elementAt(int index) { if (index<0 || index >=size) { - System.printString("Illegal Vector.elementAt"); + System.printString("Illegal Vector.elementAt\n"); + System.exit(-1); return null; } return array[index]; } public void setElementAt(Object obj, int index) { + if (index>=size) + ensureCapacity(index+1); if (index>=0 && index =size) - System.printString("Illegal insertElementAt"); + if (index<0||index>size) { + System.printString("Illegal Vector.insertElementAt\n"); + System.exit(-1); + } + if (size==array.length) { ensureCapacity(size+1); } @@ -86,8 +95,10 @@ public class Vector { } public void removeElementAt(int index) { - if (index<0||index>=size) - System.printString("Illegal remove"); + if (index<0||index>=size) { + System.printString("Illegal Vector.removeElementAt\n"); + System.exit(-1); + } for(int i=index; i<(size-1); i++) { array[i]=array[i+1]; } diff --git a/Robust/src/ClassLibrary/gnu/Double.java b/Robust/src/ClassLibrary/gnu/Double.java new file mode 100644 index 00000000..4d508b3e --- /dev/null +++ b/Robust/src/ClassLibrary/gnu/Double.java @@ -0,0 +1,630 @@ +/* Double.java -- object wrapper for double + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 + Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +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 +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., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +//package java.lang; + + +/** + * Instances of class Double represent primitive + * double values. + * + * Additionally, this class provides various helper functions and variables + * related to doubles. + * + * @author Paul Fisher + * @author Andrew Haley (aph@cygnus.com) + * @author Eric Blake (ebb9@email.byu.edu) + * @author Tom Tromey (tromey@redhat.com) + * @author Andrew John Hughes (gnu_andrew@member.fsf.org) + * @since 1.0 + * @status partly updated to 1.5 + */ +public final class Double extends Number //implements Comparable +{ + /** + * Compatible with JDK 1.0+. + */ + //private static final long serialVersionUID = -9172774392245257468L; + + /** + * The maximum positive value a double may represent + * is 1.7976931348623157e+308. + */ + public /*static*/ final double _MAX_VALUE;// = 1.7976931348623157e+308; + public double MAX_VALUE() { return _MAX_VALUE; } + /** + * The minimum positive value a double may represent + * is 5e-324. + */ + public /*static*/ final double _MIN_VALUE;// = 5e-324; + public double MIN_VALUE() { return _MIN_VALUE; } + + + /** + * The value of a double representation -1.0/0.0, negative + * infinity. + */ + //public /*static*/ final double NEGATIVE_INFINITY = -1.0 / 0.0; + + /** + * The value of a double representing 1.0/0.0, positive infinity. + */ + //public /*static*/ final double POSITIVE_INFINITY = 1.0 / 0.0; + + /** + * All IEEE 754 values of NaN have the same value in Java. + */ + //public /*static*/ final double NaN = 0.0 / 0.0; + + /** + * The number of bits needed to represent a double. + * @since 1.5 + */ + public /*static*/ final int _SIZE; + public int SIZE() { return _SIZE; } + + /** + * The primitive type double is represented by this + * Class object. + * @since 1.1 + */ + //public /*static*/ final Class TYPE = (Class) VMClassLoader.getPrimitiveClass('D'); + + /** + * The immutable value of this Double. + * + * @serial the wrapped double + */ + private final double value; + + /** + * Create a Double from the primitive double + * specified. + * + * @param value the double argument + */ + public Double(double value) + { + _MAX_VALUE = 1.7976931348623157e+308; + _MIN_VALUE = 5e-324; + //NEGATIVE_INFINITY = -1.0 / 0.0; + //POSITIVE_INFINITY = 1.0 / 0.0; + //NaN = 0.0 / 0.0; + _SIZE = 64; + + this.value = value; + } + + /** + * Create a Double from the specified String. + * This method calls Double.parseDouble(). + * + * @param s the String to convert + * @throws NumberFormatException if s cannot be parsed as a + * double + * @throws NullPointerException if s is null + * @see #parseDouble(String) + */ + public Double(String s) + { + value = parseDouble(s); + } + + /** + * Convert the double to a String. + * Floating-point string representation is fairly complex: here is a + * rundown of the possible values. "[-]" indicates that a + * negative sign will be printed if the value (or exponent) is negative. + * "<number>" means a string of digits ('0' to '9'). + * "<digit>" means a single digit ('0' to '9').
+ * + * + * + * + * + * + * + * + * + * + *
Value of DoubleString Representation
[+-] 0 [-]0.0
Between [+-] 10-3 and 107, exclusive[-]number.number
Other numeric value[-]<digit>.<number> + * E[-]<number>
[+-] infinity [-]Infinity
NaN NaN
+ * + * Yes, negative zero is a possible value. Note that there is + * always a . and at least one digit printed after + * it: even if the number is 3, it will be printed as 3.0. + * After the ".", all digits will be printed except trailing zeros. The + * result is rounded to the shortest decimal number which will parse back + * to the same double. + * + *

To create other output formats, use {@link java.text.NumberFormat}. + * + * @XXX specify where we are not in accord with the spec. + * + * @param d the double to convert + * @return the String representing the double + */ + public static String toString(double d) + { + //return VMDouble.toString(d, false); + return "0.0"; + } + + /** + * Convert a double value to a hexadecimal string. This converts as + * follows: + *

    + *
  • A NaN value is converted to the string "NaN". + *
  • Positive infinity is converted to the string "Infinity". + *
  • Negative infinity is converted to the string "-Infinity". + *
  • For all other values, the first character of the result is '-' + * if the value is negative. This is followed by '0x1.' if the + * value is normal, and '0x0.' if the value is denormal. This is + * then followed by a (lower-case) hexadecimal representation of the + * mantissa, with leading zeros as required for denormal values. + * The next character is a 'p', and this is followed by a decimal + * representation of the unbiased exponent. + *
+ * @param d the double value + * @return the hexadecimal string representation + * @since 1.5 + */ + public static String toHexString(double d) + { + /* + if (isNaN(d)) + return "NaN"; + if (isInfinite(d)) + return d < 0 ? "-Infinity" : "Infinity"; + + long bits = doubleToLongBits(d); + StringBuilder result = new StringBuilder(); + + if (bits < 0) + result.append('-'); + result.append("0x"); + + final int mantissaBits = 52; + final int exponentBits = 11; + long mantMask = (1L << mantissaBits) - 1; + long mantissa = bits & mantMask; + long expMask = (1L << exponentBits) - 1; + long exponent = (bits >>> mantissaBits) & expMask; + + result.append(exponent == 0 ? '0' : '1'); + result.append('.'); + result.append(Long.toHexString(mantissa)); + if (exponent == 0 && mantissa != 0) + { + // Treat denormal specially by inserting '0's to make + // the length come out right. The constants here are + // to account for things like the '0x'. + int offset = 4 + ((bits < 0) ? 1 : 0); + // The silly +3 is here to keep the code the same between + // the Float and Double cases. In Float the value is + // not a multiple of 4. + int desiredLength = offset + (mantissaBits + 3) / 4; + while (result.length() < desiredLength) + result.insert(offset, '0'); + } + result.append('p'); + if (exponent == 0 && mantissa == 0) + { + // Zero, so do nothing special. + } + else + { + // Apply bias. + boolean denormal = exponent == 0; + exponent -= (1 << (exponentBits - 1)) - 1; + // Handle denormal. + if (denormal) + ++exponent; + } + + result.append(Long.toString(exponent)); + return result.toString(); + */ + return "0x0"; + } + + /** + * Returns a Double object wrapping the value. + * In contrast to the Double constructor, this method + * may cache some values. It is used by boxing conversion. + * + * @param val the value to wrap + * @return the Double + * @since 1.5 + */ + public static Double valueOf(double val) + { + // We don't actually cache, but we could. + return new Double(val); + } + + /** + * Create a new Double object using the String. + * + * @param s the String to convert + * @return the new Double + * @throws NumberFormatException if s cannot be parsed as a + * double + * @throws NullPointerException if s is null. + * @see #parseDouble(String) + */ + public static Double valueOf(String s) + { + return new Double(parseDouble(s)); + } + + /** + * Parse the specified String as a double. The + * extended BNF grammar is as follows:
+ * 
+   * DecodableString:
+   *      ( [ - | + ] NaN )
+   *    | ( [ - | + ] Infinity )
+   *    | ( [ - | + ] FloatingPoint
+   *              [ f | F | d
+   *                | D] )
+   * FloatingPoint:
+   *      ( { Digit }+ [ . { Digit } ]
+   *              [ Exponent ] )
+   *    | ( . { Digit }+ [ Exponent ] )
+   * Exponent:
+   *      ( ( e | E )
+   *              [ - | + ] { Digit }+ )
+   * Digit: '0' through '9'
+   *
+ * + *

NaN and infinity are special cases, to allow parsing of the output + * of toString. Otherwise, the result is determined by calculating + * n * 10exponent to infinite precision, then rounding + * to the nearest double. Remember that many numbers cannot be precisely + * represented in floating point. In case of overflow, infinity is used, + * and in case of underflow, signed zero is used. Unlike Integer.parseInt, + * this does not accept Unicode digits outside the ASCII range. + * + *

If an unexpected character is found in the String, a + * NumberFormatException will be thrown. Leading and trailing + * 'whitespace' is ignored via String.trim(), but spaces + * internal to the actual number are not allowed. + * + *

To parse numbers according to another format, consider using + * {@link java.text.NumberFormat}. + * + * @XXX specify where/how we are not in accord with the spec. + * + * @param str the String to convert + * @return the double value of s + * @throws NumberFormatException if s cannot be parsed as a + * double + * @throws NullPointerException if s is null + * @see #MIN_VALUE + * @see #MAX_VALUE + * @see #POSITIVE_INFINITY + * @see #NEGATIVE_INFINITY + * @since 1.2 + */ + public static double parseDouble(String str) + { + //return VMDouble.parseDouble(str); + return 0.0; + } + + /** + * Return true if the double has the same + * value as NaN, otherwise return false. + * + * @param v the double to compare + * @return whether the argument is NaN. + */ + public static boolean isNaN(double v) + { + // This works since NaN != NaN is the only reflexive inequality + // comparison which returns true. + return v != v; + } + + /** + * Return true if the double has a value + * equal to either NEGATIVE_INFINITY or + * POSITIVE_INFINITY, otherwise return false. + * + * @param v the double to compare + * @return whether the argument is (-/+) infinity. + */ + public static boolean isInfinite(double v) + { + //return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY; + return false; + } + + /** + * Return true if the value of this Double + * is the same as NaN, otherwise return false. + * + * @return whether this Double is NaN + */ + public boolean isNaN() + { + return isNaN(value); + } + + /** + * Return true if the value of this Double + * is the same as NEGATIVE_INFINITY or + * POSITIVE_INFINITY, otherwise return false. + * + * @return whether this Double is (-/+) infinity + */ + public boolean isInfinite() + { + return isInfinite(value); + } + + /** + * Convert the double value of this Double + * to a String. This method calls + * Double.toString(double) to do its dirty work. + * + * @return the String representation + * @see #toString(double) + */ + public String toString() + { + return toString(value); + } + + /** + * Return the value of this Double as a byte. + * + * @return the byte value + * @since 1.1 + */ + public byte byteValue() + { + return (byte) value; + } + + /** + * Return the value of this Double as a short. + * + * @return the short value + * @since 1.1 + */ + public short shortValue() + { + return (short) value; + } + + /** + * Return the value of this Double as an int. + * + * @return the int value + */ + public int intValue() + { + return (int) value; + } + + /** + * Return the value of this Double as a long. + * + * @return the long value + */ + public long longValue() + { + return (long) value; + } + + /** + * Return the value of this Double as a float. + * + * @return the float value + */ + public float floatValue() + { + return (float) value; + } + + /** + * Return the value of this Double. + * + * @return the double value + */ + public double doubleValue() + { + return value; + } + + /** + * Return a hashcode representing this Object. Double's hash + * code is calculated by:
+ * long v = Double.doubleToLongBits(doubleValue());
+ * int hash = (int)(v^(v>>32)). + * + * @return this Object's hash code + * @see #doubleToLongBits(double) + */ + public int hashCode() + { + long v = doubleToLongBits(value); + return (int) (v ^ (v >>> 32)); + } + + /** + * Returns true if obj is an instance of + * Double and represents the same double value. Unlike comparing + * two doubles with ==, this treats two instances of + * Double.NaN as equal, but treats 0.0 and + * -0.0 as unequal. + * + *

Note that d1.equals(d2) is identical to + * doubleToLongBits(d1.doubleValue()) == + * doubleToLongBits(d2.doubleValue()). + * + * @param obj the object to compare + * @return whether the objects are semantically equal + */ + public boolean equals(Object obj) + { + if (! (obj instanceof Double)) + return false; + + double d = ((Double) obj).value; + + // Avoid call to native method. However, some implementations, like gcj, + // are better off using floatToIntBits(value) == floatToIntBits(f). + // Check common case first, then check NaN and 0. + if (value == d) + return (value != 0) || (1 / value == 1 / d); + return isNaN(value) && isNaN(d); + } + + /** + * Convert the double to the IEEE 754 floating-point "double format" bit + * layout. Bit 63 (the most significant) is the sign bit, bits 62-52 + * (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0 + * (masked by 0x000fffffffffffffL) are the mantissa. This function + * collapses all versions of NaN to 0x7ff8000000000000L. The result of this + * function can be used as the argument to + * Double.longBitsToDouble(long) to obtain the original + * double value. + * + * @param value the double to convert + * @return the bits of the double + * @see #longBitsToDouble(long) + */ + public static long doubleToLongBits(double value) + { + if (isNaN(value)) + return 0x7ff8000000000000L; + else + return 0; //VMDouble.doubleToRawLongBits(value); + } + + /** + * Convert the double to the IEEE 754 floating-point "double format" bit + * layout. Bit 63 (the most significant) is the sign bit, bits 62-52 + * (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0 + * (masked by 0x000fffffffffffffL) are the mantissa. This function + * leaves NaN alone, rather than collapsing to a canonical value. The + * result of this function can be used as the argument to + * Double.longBitsToDouble(long) to obtain the original + * double value. + * + * @param value the double to convert + * @return the bits of the double + * @see #longBitsToDouble(long) + */ + public static long doubleToRawLongBits(double value) + { + return 0; //VMDouble.doubleToRawLongBits(value); + } + + /** + * Convert the argument in IEEE 754 floating-point "double format" bit + * layout to the corresponding float. Bit 63 (the most significant) is the + * sign bit, bits 62-52 (masked by 0x7ff0000000000000L) represent the + * exponent, and bits 51-0 (masked by 0x000fffffffffffffL) are the mantissa. + * This function leaves NaN alone, so that you can recover the bit pattern + * with Double.doubleToRawLongBits(double). + * + * @param bits the bits to convert + * @return the double represented by the bits + * @see #doubleToLongBits(double) + * @see #doubleToRawLongBits(double) + */ + public static double longBitsToDouble(long bits) + { + return 0.0; //VMDouble.longBitsToDouble(bits); + } + + /** + * Compare two Doubles numerically by comparing their double + * values. The result is positive if the first is greater, negative if the + * second is greater, and 0 if the two are equal. However, this special + * cases NaN and signed zero as follows: NaN is considered greater than + * all other doubles, including POSITIVE_INFINITY, and positive + * zero is considered greater than negative zero. + * + * @param d the Double to compare + * @return the comparison + * @since 1.2 + */ + public int compareTo(Double d) + { + return compare(value, d.value); + } + + /** + * Behaves like new Double(x).compareTo(new Double(y)); in + * other words this compares two doubles, special casing NaN and zero, + * without the overhead of objects. + * + * @param x the first double to compare + * @param y the second double to compare + * @return the comparison + * @since 1.4 + */ + public static int compare(double x, double y) + { + // handle the easy cases: + if (x < y) + return -1; + if (x > y) + return 1; + + // handle equality respecting that 0.0 != -0.0 (hence not using x == y): + long lx = doubleToRawLongBits(x); + long ly = doubleToRawLongBits(y); + if (lx == ly) + return 0; + + // handle NaNs: + if (x != x) + return (y != y) ? 0 : 1; + else if (y != y) + return -1; + + // handle +/- 0.0 + return (lx < ly) ? -1 : 1; + } +} diff --git a/Robust/src/ClassLibrary/gnu/Number.java b/Robust/src/ClassLibrary/gnu/Number.java new file mode 100644 index 00000000..cf16217a --- /dev/null +++ b/Robust/src/ClassLibrary/gnu/Number.java @@ -0,0 +1,163 @@ +/* Number.java =- abstract superclass of numeric objects + Copyright (C) 1998, 2001, 2002, 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +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 +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., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +//package java.lang; + +//import java.io.Serializable; + +/** + * Number is a generic superclass of all the numeric classes, including + * the wrapper classes {@link Byte}, {@link Short}, {@link Integer}, + * {@link Long}, {@link Float}, and {@link Double}. Also worth mentioning + * are the classes in {@link java.math}. + * + * It provides ways to convert numeric objects to any primitive. + * + * @author Paul Fisher + * @author John Keiser + * @author Warren Levy + * @author Eric Blake (ebb9@email.byu.edu) + * @since 1.0 + * @status updated to 1.4 + */ +public /*abstract*/ class Number //implements Serializable +{ + /** + * Compatible with JDK 1.1+. + */ + //private static final long serialVersionUID = -8742448824652078965L; + + /** + * Table for calculating digits, used in Character, Long, and Integer. + */ + /*static*/ final char[] digits; + + /** + * The basic constructor (often called implicitly). + */ + public Number() + { + digits = new char[36]; + digits[0] = '0'; + digits[1] = '1'; + digits[2] = '2'; + digits[3] = '3'; + digits[4] = '4'; + digits[5] = '5'; + digits[6] = '6'; + digits[7] = '7'; + digits[8] = '8'; + digits[9] = '9'; + digits[10] = 'a'; + digits[11] = 'b'; + digits[12] = 'c'; + digits[13] = 'd'; + digits[14] = 'e'; + digits[15] = 'f'; + digits[16] = 'g'; + digits[17] = 'h'; + digits[18] = 'i'; + digits[19] = 'j'; + digits[20] = 'k'; + digits[21] = 'l'; + digits[22] = 'm'; + digits[23] = 'n'; + digits[24] = 'o'; + digits[25] = 'p'; + digits[26] = 'q'; + digits[27] = 'r'; + digits[28] = 's'; + digits[29] = 't'; + digits[30] = 'u'; + digits[31] = 'v'; + digits[32] = 'w'; + digits[33] = 'x'; + digits[34] = 'y'; + digits[35] = 'z'; + } + + /** + * Return the value of this Number as an int. + * + * @return the int value + */ + public /*abstract*/ int intValue(){} + + /** + * Return the value of this Number as a long. + * + * @return the long value + */ + public /*abstract*/ long longValue(){} + + /** + * Return the value of this Number as a float. + * + * @return the float value + */ + public /*abstract*/ float floatValue(){} + + /** + * Return the value of this Number as a float. + * + * @return the double value + */ + public /*abstract*/ double doubleValue(){} + + /** + * Return the value of this Number as a byte. + * + * @return the byte value + * @since 1.1 + */ + public byte byteValue() + { + return (byte) intValue(); + } + + /** + * Return the value of this Number as a short. + * + * @return the short value + * @since 1.1 + */ + public short shortValue() + { + return (short) intValue(); + } +} -- 2.34.1