1. Added a BigInt class

2. Error rather than crash when regexp pattern is encountered 3. Small
bug fixes. 4. Added support for filter and subRange in all array classes
(was missing before). 5. Prepared for generalization of implicit
conversions as needed for BigInt (but this is not yet enabled).

13 files changed, 530 insertions, 16 deletions

diff --git a/src/library/scala/BigInt.scala b/src/library/scala/BigInt.scala
new file mode 100755
index 0000000000..fd877f6124
--- /dev/null
+++ b/src/library/scala/BigInt.scala
@@ -0,0 +1,331 @@
+package scala;
+
+import java.math.BigInteger
+import java.util.Random
+
+/**
+ *  @author  Martin Odersky
+ *  @version 1.0, 15/07/2003
+ */
+object BigInt {
+
+  private val minCached = -1024;
+  private val maxCached = 1024;
+  private val cache = new Array[BigInt](maxCached - minCached + 1)
+
+  /** Constructs a BigInt whose value is equal to that of the specified integer value.
+   */
+  def apply(i: Int): BigInt =
+    if (minCached <= i && i <= maxCached) {
+      var n = cache(i)
+      if (n == null) { n = new BigInt(BigInteger.valueOf(i)); cache(i) = n }
+      n
+    } else new BigInt(BigInteger.valueOf(i))
+
+  /** Constructs a BigInt whose value is equal to that of the specified long value.
+   */
+  def apply(l: Long): BigInt =
+    if (minCached <= l && l <= maxCached) apply(l.toInt)
+    else new BigInt(BigInteger.valueOf(l))
+
+  /** Translates a byte array containing the two's-complement binary
+   *  representation of a BigInt into a BigInt.
+   */
+  def apply(x: Array[byte]): BigInt =
+    new BigInt(new BigInteger(x))
+
+  /** Translates the sign-magnitude representation of a BigInt into a BigInt.
+   */
+  def apply(signum: Int, magnitude: Array[byte]): BigInt =
+    new BigInt(new BigInteger(signum, magnitude))
+
+  /** Constructs a randomly generated positive BigInt that is probably prime,
+   *  with the specified bitLength.
+   */
+  def apply(bitlength: Int, certaInty: Int, rnd: Random): BigInt =
+    new BigInt(new BigInteger(bitlength, certaInty, rnd))
+
+  /** Constructs a randomly generated BigInt, uniformly distributed over the range
+   *  0 to (2 ^ numBits - 1), inclusive.
+   */
+  def apply(numbits: Int, rnd: Random): BigInt =
+    new BigInt(new BigInteger(numbits, rnd))
+
+  /** Translates the decimal String representation of a BigInt into a BigInt.
+   */
+  def apply(x: String): BigInt =
+    new BigInt(new BigInteger(x))
+
+  /** Translates the String representation of a BigInt in the
+   *  specified radix into a BigInt.
+   */
+  def apply(x: String, radix: Int): BigInt =
+    new BigInt(new BigInteger(x, radix))
+
+  /** Returns a positive BigInt that is probably prime, with the specified bitLength.
+   */
+  def probablePrime(bitLength: Int, rnd: Random): BigInt =
+    new BigInt(BigInteger.probablePrime(bitLength, rnd))
+
+  /** Implicit conversion from int to BigInt
+   */
+  implicit def int2bigInt(i: Int): BigInt = apply(i)
+
+  /** Implicit copnversion from long to BigInt
+   */
+  implicit def long2bigInt(l: Long): BigInt = apply(l)
+
+  /** Implicit conversion from BigInt to Ordered
+   */
+  implicit def bigInt2ordered(x: BigInt): Ordered[BigInt] = new Ordered[BigInt] with Proxy {
+    def self: Any = x;
+    def compareTo [b >: BigInt <% Ordered[b]](y: b): Int = y match {
+      case y: BigInt => x.bigInteger.compareTo(y.bigInteger)
+      case _ => -(y compareTo x)
+    }
+  }
+}
+
+[serializable]
+class BigInt(val bigInteger: BigInteger) extends runtime.BoxedNumber {
+
+  /** Returns the hash code for this BigInt. */
+  override def hashCode(): Int = this.bigInteger.hashCode()
+
+  /** Compares this BigInt with the specified value for equality.
+   */
+  override def equals (that: Any): boolean = that match {
+    case that: runtime.BoxedDouble => this.bigInteger.doubleValue == that
+    case that: runtime.BoxedFloat  => this.bigInteger.floatValue == that
+    case that: runtime.BoxedNumber => this equals BigInt(that.longValue)
+    case _ => false
+  }
+
+  /** Compares this BigInt with the specified BigInt for equality.
+   */
+  def equals (that: BigInt): boolean =
+    this.bigInteger.compareTo(that.bigInteger) == 0
+
+  /** Compares this BigInt with the specified BigInt
+   */
+  def compareTo (that: BigInt): int = this.bigInteger.compareTo(that.bigInteger)
+
+  /** Less-than-or-equals comparison of BigInts
+   */
+  def <= (that: BigInt): boolean = this.bigInteger.compareTo(that.bigInteger) <= 0
+
+  /** Greater-than-or-equals comparison of BigInts
+   */
+  def >= (that: BigInt): boolean = this.bigInteger.compareTo(that.bigInteger) >= 0
+
+  /** Less-than of BigInts
+   */
+  def <  (that: BigInt): boolean = this.bigInteger.compareTo(that.bigInteger) <  0
+
+  /** Greater-than comparison of BigInts
+   */
+  def >  (that: BigInt): boolean = this.bigInteger.compareTo(that.bigInteger) >= 0
+
+  /** Addition of BigInts
+   */
+  def +  (that: BigInt): BigInt = new BigInt(this.bigInteger.add(that.bigInteger))
+
+  /** Subtraction of BigInts
+   */
+  def -  (that: BigInt): BigInt = new BigInt(this.bigInteger.subtract(that.bigInteger))
+
+  /** Multiplication of BigInts
+   */
+  def *  (that: BigInt): BigInt = new BigInt(this.bigInteger.multiply(that.bigInteger))
+
+  /** Division of BigInts
+   */
+  def /  (that: BigInt): BigInt = new BigInt(this.bigInteger.divide(that.bigInteger))
+
+  /** Remainder of BigInts
+   */
+  def %  (that: BigInt): BigInt = new BigInt(this.bigInteger.remainder(that.bigInteger))
+
+  /** Returns a pair of two BigInts containing (this / that) and (this % that).
+   */
+  def /% (that: BigInt): Pair[BigInt, BigInt] = {
+    val dr = this.bigInteger.divideAndRemainder(that.bigInteger)
+    Pair(new BigInt(dr(0)), new BigInt(dr(1)))
+  }
+
+  /** Leftshift of BigInt
+   */
+  def << (n: Int): BigInt = new BigInt(this.bigInteger.shiftLeft(n))
+
+  /** (Signed) rightshift of BigInt
+   */
+  def >> (n: Int): BigInt = new BigInt(this.bigInteger.shiftRight(n))
+
+  /** Bitwise and of BigInts
+   */
+  def &  (that: BigInt): BigInt = new BigInt(this.bigInteger.and(that.bigInteger))
+
+  /** Bitwise or of BigInts
+   */
+  def |  (that: BigInt): BigInt = new BigInt(this.bigInteger.or (that.bigInteger))
+
+  /** Bitwise exclusive-or of BigInts
+   */
+  def ^  (that: BigInt): BigInt = new BigInt(this.bigInteger.xor(that.bigInteger))
+
+  /** Bitwise and-not of BigInts. Returns a BigInt whose value is (this & ~that).
+   */
+  def &~ (that: BigInt): BigInt = new BigInt(this.bigInteger.andNot(that.bigInteger))
+
+  /** Returns the greatest common divisor of abs(this) and abs(that)
+   */
+  def gcd (that: BigInt): BigInt = new BigInt(this.bigInteger.gcd(that.bigInteger))
+
+  /** Returns a BigInt whose value is (this mod m).
+   *  This method differs from `%' in that it always returns a non-negative BigInt.
+   */
+  def mod (that: BigInt): BigInt = new BigInt(this.bigInteger.mod(that.bigInteger))
+
+  /** Returns the minimum of this and that
+   */
+  def min (that: BigInt): BigInt = new BigInt(this.bigInteger.min(that.bigInteger))
+
+  /** Returns the maximum of this and that
+   */
+  def max (that: BigInt): BigInt = new BigInt(this.bigInteger.max(that.bigInteger))
+
+  /** Returns a BigInt whose value is (<tt>this</tt> raised to the power of <tt>exp</tt>).
+   */
+  def pow (exp: Int): BigInt = new BigInt(this.bigInteger.pow(exp))
+
+  /** Returns a BigInt whose value is
+   *  (<tt>this</tt> raised to the power of <tt>exp</tt> modulo <tt>m</tt>).
+   */
+  def modPow (exp: BigInt, m: BigInt): BigInt =
+    new BigInt(this.bigInteger.modPow(exp.bigInteger, m.bigInteger))
+
+  /** Returns a BigInt whose value is (the inverse of <tt>this</tt> modulo <tt>m</tt>).
+   */
+  def modInverse (m: BigInt): BigInt = new BigInt(this.bigInteger.modInverse(m.bigInteger))
+
+  /** Returns a BigInt whose value is the negation of this BigInt
+   */
+  def - : BigInt   = new BigInt(this.bigInteger.negate())
+
+  /** Returns the absolute value of this BigInt
+   */
+  def abs: BigInt = new BigInt(this.bigInteger.abs())
+
+  /** Returns the sign of this BigInt, i.e.
+   *   -1 if it is less than 0,
+   *   +1 if it is greater than 0
+   *   0  if it is equal to 0
+   */
+  def signum: Int = this.bigInteger.signum()
+
+  /** Returns the bitwise complement of this BigNum
+   */
+  def ~ : BigInt   = new BigInt(this.bigInteger.not())
+
+  /** Returns true if and only if the designated bit is set.
+   */
+  def testBit (n: Int): Boolean = this.bigInteger.testBit(n)
+
+  /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit set.
+   */
+  def setBit  (n: Int): BigInt  = new BigInt(this.bigInteger.setBit(n))
+
+  /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit cleared.
+   */
+  def clearBit(n: Int): BigInt  = new BigInt(this.bigInteger.clearBit(n))
+
+  /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit flipped.
+   */
+  def flipBit (n: Int): BigInt  = new BigInt(this.bigInteger.flipBit(n))
+
+  /** Returns the index of the rightmost (lowest-order) one bit in this BigInt
+   * (the number of zero bits to the right of the rightmost one bit).
+   */
+  def lowestSetBit: int         = this.bigInteger.getLowestSetBit()
+
+  /** Returns the number of bits in the minimal two's-complement representation of this BigInt,
+   *  excluding a sign bit.
+   */
+  def bitLength: int            = this.bigInteger.bitLength()
+
+  /** Returns the number of bits in the two's complement representation of this BigInt
+   *  that differ from its sign bit.
+   */
+  def bitCount: int             = this.bigInteger.bitCount()
+
+  /** Returns true if this BigInt is probably prime, false if it's definitely composite.
+   *  @param certainty  a measure of the uncertainty that the caller is willing to tolerate:
+   *                    if the call returns true the probability that this BigInt is prime
+   *                    exceeds (1 - 1/2 ^ certainty).
+   *                    The execution time of this method is proportional to the value of
+   *                    this parameter.
+   */
+  def isProbablePrime(certainty: Int) = this.bigInteger.isProbablePrime(certainty)
+
+  /** Converts this BigInt to a <tt>byte</tt>.
+   *  If the BigInt is too big to fit in a byte, only the low-order 8 bits are returned.
+   *  Note that this conversion can lose information about the overall magnitude of the
+   *  BigInt value as well as return a result with the opposite sign.
+   */
+  def byteValue   = intValue.toByte
+
+  /** Converts this BigInt to a <tt>short</tt>.
+   *  If the BigInt is too big to fit in a byte, only the low-order 16 bits are returned.
+   *  Note that this conversion can lose information about the overall magnitude of the
+   *  BigInt value as well as return a result with the opposite sign.
+   */
+  def shortValue  = intValue.toShort
+
+  /** Converts this BigInt to a <tt>char</tt>.
+   *  If the BigInt is too big to fit in a char, only the low-order 16 bits are returned.
+   *  Note that this conversion can lose information about the overall magnitude of the
+   *  BigInt value and that it always returns a positive result.
+   */
+  def charValue   = intValue.toChar
+
+  /** Converts this BigInt to an <tt>int</tt>.
+   *  If the BigInt is too big to fit in a char, only the low-order 32 bits are returned.
+   *  Note that this conversion can lose information about the overall magnitude of the
+   *  BigInt value as well as return a result with the opposite sign.
+   */
+  def intValue    = this.bigInteger.intValue
+
+  /** Converts this BigInt to a <tt>long</tt>.
+   *  If the BigInt is too big to fit in a char, only the low-order 64 bits are returned.
+   *  Note that this conversion can lose information about the overall magnitude of the
+   *  BigInt value as well as return a result with the opposite sign.
+   */
+  def longValue   = this.bigInteger.longValue
+
+  /** Converts this BigInt to a <tt>float</tt>.
+   *  if this BigInt has too great a magnitude to represent as a float,
+   *  it will be converted to Float.NEGATIVE_INFINITY or Float.POSITIVE_INFINITY as appropriate.
+   */
+  def floatValue  = this.bigInteger.floatValue
+
+  /** Converts this BigInt to a <tt>double</tt>.
+   *  if this BigInt has too great a magnitude to represent as a float,
+   *  it will be converted to Float.NEGATIVE_INFINITY or Float.POSITIVE_INFINITY as appropriate.
+   */
+  def doubleValue = this.bigInteger.doubleValue
+
+  /** Returns the decimal String representation of this BigInt.
+   */
+  override def toString(): String = this.bigInteger.toString()
+
+  /** Returns the String representation in the specified radix of this BigInt.
+   */
+  def toString(radix: Int): String = this.bigInteger.toString(radix)
+
+  /** Returns a byte array containing the two's-complement representation of this BigInt.
+   *  The byte array will be in big-endian byte-order: the most significant byte is in the
+   *  zeroth element. The array will contain the minimum number of bytes required to represent
+   *  this BigInt, including at least one sign bit.
+   */
+  def toByteArray: Array[Byte] = this.bigInteger.toByteArray()
+}
diff --git a/src/library/scala/Seq.scala b/src/library/scala/Seq.scala
index 14a9368522..66c44829e7 100644
--- a/src/library/scala/Seq.scala
+++ b/src/library/scala/Seq.scala
@@ -156,7 +156,7 @@ trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Iterable[A] {
   */
   def toList: List[A] = elements.toList;
 
-  /** Converts this sequence to an Array */
+  /** Converts this sequence to a fresh Array */
   def toArray[B >: A]: Array[B] = elements.copyToArray(new Array[B](length), 0);
 
   /** Fills the given array <code>xs</code> with the elements of
diff --git a/src/library/scala/runtime/BoxedAnyArray.scala b/src/library/scala/runtime/BoxedAnyArray.scala
index 1945016977..92359d8555 100644
--- a/src/library/scala/runtime/BoxedAnyArray.scala
+++ b/src/library/scala/runtime/BoxedAnyArray.scala
@@ -219,4 +219,28 @@ final class BoxedAnyArray(val length: Int) extends BoxedArray {
     var dest1 = adapt(dest)
     Array.copy(if (unboxed != null) unboxed else boxed, from, dest1, to, len)
   }
+
+  override def subArray(start: Int, end: Int): Object = {
+    val result = new BoxedAnyArray(end - start);
+    Array.copy(this, 0, result, 0, end - start)
+    result
+  }
+
+  override def filter(p: Any => Boolean): Object = {
+    val include = new Array[Boolean](length);
+    var len = 0;
+    var i = 0;
+    while (i < length) {
+      if (p(this(i))) { include(i) = true; len = len + 1 }
+      i = i + 1
+    }
+    val result = new BoxedAnyArray(len);
+    len = 0;
+    i = 0;
+    while (len < result.length) {
+      if (include(i)) { result(len) = this(i); len = len + 1 }
+      i = i + 1
+    }
+    result
+  }
 }
diff --git a/src/library/scala/runtime/BoxedArray.scala b/src/library/scala/runtime/BoxedArray.scala
index 8fad91eb2e..c631c0292e 100644
--- a/src/library/scala/runtime/BoxedArray.scala
+++ b/src/library/scala/runtime/BoxedArray.scala
@@ -46,11 +46,11 @@ abstract class BoxedArray extends PartialFunction[Int, Object] with Seq[Object]
     Array.copy(value, from, dest, to, len)
   }
 
-  def subArray(from: Int, end: Int): Object = null
+  def subArray(from: Int, end: Int): Object
 
-  def filter(p: Any => Boolean): Object = null
+  def filter(p: Any => Boolean): Object
 
-  def map[b](f: Any => b): Array[b] = {
+  final def map[b](f: Any => b): Array[b] = {
     val len = length
     val result = new Array[b](len)
     var i = 0
@@ -61,7 +61,7 @@ abstract class BoxedArray extends PartialFunction[Int, Object] with Seq[Object]
     result
   }
 
-  def flatMap[b](f: Any => Array[b]): Array[b] = {
+  final def flatMap[b](f: Any => Array[b]): Array[b] = {
     val len = length
     val tmp = new Array[Array[b]](len)
     var i = 0
diff --git a/src/library/scala/runtime/BoxedBooleanArray.scala b/src/library/scala/runtime/BoxedBooleanArray.scala
index bc91e555a8..a157047652 100644
--- a/src/library/scala/runtime/BoxedBooleanArray.scala
+++ b/src/library/scala/runtime/BoxedBooleanArray.scala
@@ -31,5 +31,29 @@ final class BoxedBooleanArray(val value: Array[Boolean]) extends BoxedArray {
   );
 
   override def hashCode(): Int = value.hashCode();
+
+  def subArray(start: Int, end: Int): Array[Boolean] = {
+    val result = new Array[Boolean](end - start);
+    Array.copy(value, 0, result, 0, end - start)
+    result
+  }
+
+  def filter(p: Any => Boolean): Array[Boolean] = {
+    val include = new Array[Boolean](value.length);
+    var len = 0;
+    var i = 0;
+    while (i < value.length) {
+      if (p(value(i))) { include(i) = true; len = len + 1 }
+      i = i + 1
+    }
+    val result = new Array[Boolean](len);
+    len = 0;
+    i = 0;
+    while (len < result.length) {
+      if (include(i)) { result(len) = value(i); len = len + 1 }
+      i = i + 1
+    }
+    result
+  }
 }
 
diff --git a/src/library/scala/runtime/BoxedByteArray.scala b/src/library/scala/runtime/BoxedByteArray.scala
index fa429af1e6..d5195da463 100644
--- a/src/library/scala/runtime/BoxedByteArray.scala
+++ b/src/library/scala/runtime/BoxedByteArray.scala
@@ -31,5 +31,29 @@ final class BoxedByteArray(val value: Array[Byte]) extends BoxedArray {
   );
 
   override def hashCode(): Int = value.hashCode();
+
+  def subArray(start: Int, end: Int): Array[Byte] = {
+    val result = new Array[Byte](end - start);
+    Array.copy(value, 0, result, 0, end - start)
+    result
+  }
+
+  def filter(p: Any => Boolean): Array[Byte] = {
+    val include = new Array[Boolean](value.length);
+    var len = 0;
+    var i = 0;
+    while (i < value.length) {
+      if (p(value(i))) { include(i) = true; len = len + 1 }
+      i = i + 1
+    }
+    val result = new Array[Byte](len);
+    len = 0;
+    i = 0;
+    while (len < result.length) {
+      if (include(i)) { result(len) = value(i); len = len + 1 }
+      i = i + 1
+    }
+    result
+  }
 }
 
diff --git a/src/library/scala/runtime/BoxedCharArray.scala b/src/library/scala/runtime/BoxedCharArray.scala
index 8510b48b21..bcf42c8d7b 100644
--- a/src/library/scala/runtime/BoxedCharArray.scala
+++ b/src/library/scala/runtime/BoxedCharArray.scala
@@ -31,5 +31,29 @@ final class BoxedCharArray(val value: Array[Char]) extends BoxedArray {
   );
 
   override def hashCode(): Int = value.hashCode();
+
+  def subArray(start: Int, end: Int): Array[Char] = {
+    val result = new Array[Char](end - start);
+    Array.copy(value, 0, result, 0, end - start)
+    result
+  }
+
+  def filter(p: Any => Boolean): Array[Char] = {
+    val include = new Array[Boolean](value.length);
+    var len = 0;
+    var i = 0;
+    while (i < value.length) {
+      if (p(value(i))) { include(i) = true; len = len + 1 }
+      i = i + 1
+    }
+    val result = new Array[Char](len);
+    len = 0;
+    i = 0;
+    while (len < result.length) {
+      if (include(i)) { result(len) = value(i); len = len + 1 }
+      i = i + 1
+    }
+    result
+  }
 }
 
diff --git a/src/library/scala/runtime/BoxedDoubleArray.scala b/src/library/scala/runtime/BoxedDoubleArray.scala
index 4e78325513..7affbd86d3 100644
--- a/src/library/scala/runtime/BoxedDoubleArray.scala
+++ b/src/library/scala/runtime/BoxedDoubleArray.scala
@@ -31,5 +31,29 @@ final class BoxedDoubleArray(val value: Array[Double]) extends BoxedArray {
   );
 
   override def hashCode(): Int = value.hashCode();
+
+  def subArray(start: Int, end: Int): Array[Double] = {
+    val result = new Array[Double](end - start);
+    Array.copy(value, 0, result, 0, end - start)
+    result
+  }
+
+  def filter(p: Any => Boolean): Array[Double] = {
+    val include = new Array[Boolean](value.length);
+    var len = 0;
+    var i = 0;
+    while (i < value.length) {
+      if (p(value(i))) { include(i) = true; len = len + 1 }
+      i = i + 1
+    }
+    val result = new Array[Double](len);
+    len = 0;
+    i = 0;
+    while (len < result.length) {
+      if (include(i)) { result(len) = value(i); len = len + 1 }
+      i = i + 1
+    }
+    result
+  }
 }
 
diff --git a/src/library/scala/runtime/BoxedFloatArray.scala b/src/library/scala/runtime/BoxedFloatArray.scala
index ffdba54168..cd1887408f 100644
--- a/src/library/scala/runtime/BoxedFloatArray.scala
+++ b/src/library/scala/runtime/BoxedFloatArray.scala
@@ -31,5 +31,29 @@ final class BoxedFloatArray(val value: Array[Float]) extends BoxedArray {
   );
 
   override def hashCode(): Int = value.hashCode();
+
+  def subArray(start: Int, end: Int): Array[Float] = {
+    val result = new Array[Float](end - start);
+    Array.copy(value, 0, result, 0, end - start)
+    result
+  }
+
+  def filter(p: Any => Boolean): Array[Float] = {
+    val include = new Array[Boolean](value.length);
+    var len = 0;
+    var i = 0;
+    while (i < value.length) {
+      if (p(value(i))) { include(i) = true; len = len + 1 }
+      i = i + 1
+    }
+    val result = new Array[Float](len);
+    len = 0;
+    i = 0;
+    while (len < result.length) {
+      if (include(i)) { result(len) = value(i); len = len + 1 }
+      i = i + 1
+    }
+    result
+  }
 }
 
diff --git a/src/library/scala/runtime/BoxedIntArray.scala b/src/library/scala/runtime/BoxedIntArray.scala
index bbfc82407c..ebd51114af 100644
--- a/src/library/scala/runtime/BoxedIntArray.scala
+++ b/src/library/scala/runtime/BoxedIntArray.scala
@@ -32,13 +32,13 @@ final class BoxedIntArray(val value: Array[Int]) extends BoxedArray {
 
   override def hashCode(): Int = value.hashCode();
 
-  override def subArray(start: Int, end: Int): Array[Int] = {
+  def subArray(start: Int, end: Int): Array[Int] = {
     val result = new Array[Int](end - start);
     Array.copy(value, 0, result, 0, end - start)
     result
   }
 
-  override def filter(p: Any => Boolean): Array[Int] = {
+  def filter(p: Any => Boolean): Array[Int] = {
     val include = new Array[Boolean](value.length);
     var len = 0;
     var i = 0;
diff --git a/src/library/scala/runtime/BoxedLongArray.scala b/src/library/scala/runtime/BoxedLongArray.scala
index e0cbe169b6..8eb83ee10c 100644
--- a/src/library/scala/runtime/BoxedLongArray.scala
+++ b/src/library/scala/runtime/BoxedLongArray.scala
@@ -31,5 +31,29 @@ final class BoxedLongArray(val value: Array[Long]) extends BoxedArray {
   );
 
   override def hashCode(): Int = value.hashCode();
+
+  def subArray(start: Int, end: Int): Array[Long] = {
+    val result = new Array[Long](end - start);
+    Array.copy(value, 0, result, 0, end - start)
+    result
+  }
+
+  def filter(p: Any => Boolean): Array[Long] = {
+    val include = new Array[Boolean](value.length);
+    var len = 0;
+    var i = 0;
+    while (i < value.length) {
+      if (p(value(i))) { include(i) = true; len = len + 1 }
+      i = i + 1
+    }
+    val result = new Array[Long](len);
+    len = 0;
+    i = 0;
+    while (len < result.length) {
+      if (include(i)) { result(len) = value(i); len = len + 1 }
+      i = i + 1
+    }
+    result
+  }
 }
 
diff --git a/src/library/scala/runtime/BoxedObjectArray.scala b/src/library/scala/runtime/BoxedObjectArray.scala
index 31db3ca428..25c4d739c5 100644
--- a/src/library/scala/runtime/BoxedObjectArray.scala
+++ b/src/library/scala/runtime/BoxedObjectArray.scala
@@ -53,13 +53,4 @@ final class BoxedObjectArray(val value: Array[Object]) extends BoxedArray {
     }
     result
   }
-
-/*
-  def map(p: Any => Any): BoxedAnyArray = {
-    val include = new Array
-    var len = 0
-    for (val x <- value) if (p(x)) { tmp(len) = x; len = len + 1 }
-    slice(tmp, 0, len)
-  }
-*/
 }
diff --git a/src/library/scala/runtime/BoxedShortArray.scala b/src/library/scala/runtime/BoxedShortArray.scala
index 3ce763377b..796d82957f 100644
--- a/src/library/scala/runtime/BoxedShortArray.scala
+++ b/src/library/scala/runtime/BoxedShortArray.scala
@@ -31,5 +31,29 @@ final class BoxedShortArray(val value: Array[Short]) extends BoxedArray {
   );
 
   override def hashCode(): Int = value.hashCode();
+
+  def subArray(start: Int, end: Int): Array[Short] = {
+    val result = new Array[Short](end - start);
+    Array.copy(value, 0, result, 0, end - start)
+    result
+  }
+
+  def filter(p: Any => Boolean): Array[Short] = {
+    val include = new Array[Boolean](value.length);
+    var len = 0;
+    var i = 0;
+    while (i < value.length) {
+      if (p(value(i))) { include(i) = true; len = len + 1 }
+      i = i + 1
+    }
+    val result = new Array[Short](len);
+    len = 0;
+    i = 0;
+    while (len < result.length) {
+      if (include(i)) { result(len) = value(i); len = len + 1 }
+      i = i + 1
+    }
+    result
+  }
 }