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). git-svn-id: http://lampsvn.epfl.ch/svn-repos/scala/scala/trunk@6748 5e8d7ff9-d8ef-0310-90f0-a4852d11357a
This commit is contained in:
odersky
parent
bc5b41e9a7
commit
1f6380c8f8
|
|
@ -121,7 +121,7 @@ with RightTracers {
|
|||
_ : Literal => ; // no variables
|
||||
|
||||
case _ =>
|
||||
error("unknown pattern node:" + tree + " = " + tree.getClass());
|
||||
cunit.error(tree.pos, "unknown pattern node:" + tree + " = " + tree.getClass());
|
||||
}
|
||||
}
|
||||
traverse(pat);
|
||||
|
|
@ -243,7 +243,7 @@ with RightTracers {
|
|||
//case _ =>
|
||||
// Console.println(pat);
|
||||
// Console.println(pat.getClass());
|
||||
// scala.Predef.error(" what is this ? ")
|
||||
// scala.Predef.error"( what is this ? ")
|
||||
}
|
||||
|
||||
var res:List[CaseDef] = Nil;
|
||||
|
|
@ -295,7 +295,8 @@ with RightTracers {
|
|||
*/
|
||||
|
||||
System.out.println("" + sel + " match " + ocases);
|
||||
scala.Predef.error("regular expressions not yet implemented");
|
||||
cunit.error(sel.pos, "regular expressions not yet implemented");
|
||||
sel
|
||||
} else {
|
||||
val pm = new PatternMatcher();
|
||||
pm.initialize(sel, currentOwner, true );
|
||||
|
|
|
|||
|
|
@ -964,7 +964,9 @@ trait Symbols requires SymbolTable {
|
|||
override def cloneSymbolImpl(owner: Symbol): Symbol = {
|
||||
throw new Error("should not clone a type skolem");
|
||||
}
|
||||
override def nameString: String = super.nameString + "&";
|
||||
override def nameString: String =
|
||||
if (settings.debug.value) (super.nameString + "&")
|
||||
else super.nameString;
|
||||
}
|
||||
|
||||
/** A class for class symbols */
|
||||
|
|
|
|||
|
|
@ -125,6 +125,14 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
|
|||
} else
|
||||
transformMixinInfo(erasure(tp));
|
||||
|
||||
val deconstMap = new TypeMap {
|
||||
def apply(tp: Type): Type = tp match {
|
||||
case PolyType(_, _) => mapOver(tp)
|
||||
case MethodType(_, _) => mapOver(tp)
|
||||
case _ => tp.deconst
|
||||
}
|
||||
}
|
||||
|
||||
// -------- boxing/unboxing --------------------------------------------------------
|
||||
|
||||
override def newTyper(context: Context) = new Eraser(context);
|
||||
|
|
@ -477,6 +485,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
|
|||
val otpe = erasure(other.tpe);
|
||||
val bridgeNeeded = atPhase(phase.next) (
|
||||
!(other.tpe =:= member.tpe) &&
|
||||
!(deconstMap(other.tpe) =:= deconstMap(member.tpe)) &&
|
||||
{ var e = bridgesScope.lookupEntry(member.name);
|
||||
while (e != null && !((e.sym.tpe =:= otpe) && (bridgeTarget(e.sym) == member)))
|
||||
e = bridgesScope.lookupNextEntry(e);
|
||||
|
|
|
|||
|
|
@ -71,6 +71,7 @@ trait Contexts requires Analyzer {
|
|||
// after the this constructor call?
|
||||
var reportAmbiguousErrors = false;
|
||||
var reportGeneralErrors = false;
|
||||
var implicitsEnabled = false;
|
||||
var checking = false;
|
||||
|
||||
var savedTypeBounds: List[Pair[Symbol, Type]] = List();
|
||||
|
|
@ -102,6 +103,7 @@ trait Contexts requires Analyzer {
|
|||
c.imports = imports;
|
||||
c.reportAmbiguousErrors = this.reportAmbiguousErrors;
|
||||
c.reportGeneralErrors = this.reportGeneralErrors;
|
||||
c.implicitsEnabled = this.implicitsEnabled;
|
||||
c.checking = this.checking;
|
||||
c.outer = this;
|
||||
c
|
||||
|
|
@ -111,6 +113,7 @@ trait Contexts requires Analyzer {
|
|||
val c = make(unit, EmptyTree, owner, scope, imports);
|
||||
c.reportAmbiguousErrors = true;
|
||||
c.reportGeneralErrors = true;
|
||||
c.implicitsEnabled = true;
|
||||
c
|
||||
}
|
||||
|
||||
|
|
@ -133,6 +136,7 @@ trait Contexts requires Analyzer {
|
|||
val c = make(tree);
|
||||
c.reportAmbiguousErrors = reportAmbiguousErrors;
|
||||
c.reportGeneralErrors = false;
|
||||
c.implicitsEnabled = false;
|
||||
c
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -667,16 +667,20 @@ trait Infer requires Analyzer {
|
|||
/** Try inference twice, once without views and once with views, unless views are already disabled.
|
||||
*/
|
||||
def tryTwice(infer: => unit): unit = {
|
||||
if (context.reportGeneralErrors) {
|
||||
if (context.implicitsEnabled) {
|
||||
val reportGeneralErrors = context.reportGeneralErrors;
|
||||
context.reportGeneralErrors = false;
|
||||
context.implicitsEnabled = false;
|
||||
try {
|
||||
infer
|
||||
} catch {
|
||||
case ex: TypeError =>
|
||||
context.reportGeneralErrors = true;
|
||||
context.reportGeneralErrors = reportGeneralErrors;
|
||||
context.implicitsEnabled = true;
|
||||
infer
|
||||
}
|
||||
context.reportGeneralErrors = true
|
||||
context.reportGeneralErrors = reportGeneralErrors
|
||||
context.implicitsEnabled = true
|
||||
} else infer
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -21,6 +21,8 @@ trait Typers requires Analyzer {
|
|||
var selcnt = 0
|
||||
var implcnt = 0
|
||||
var impltime = 0l
|
||||
|
||||
final val xviews = false
|
||||
|
||||
private val transformed = new HashMap[Tree, Tree]
|
||||
|
||||
|
|
@ -40,7 +42,7 @@ trait Typers requires Analyzer {
|
|||
val infer = new Inferencer(context0) {
|
||||
override def isCoercible(tp: Type, pt: Type): boolean = (
|
||||
tp.isError || pt.isError ||
|
||||
context0.reportGeneralErrors && // this condition prevents chains of views
|
||||
context0.implicitsEnabled && // this condition prevents chains of views
|
||||
inferView(Position.NOPOS, tp, pt, false) != EmptyTree
|
||||
)
|
||||
}
|
||||
|
|
@ -56,10 +58,10 @@ trait Typers requires Analyzer {
|
|||
}
|
||||
}
|
||||
|
||||
private def inferView(pos: int, from: Type, name: Name, reportAmbiguous: boolean): Tree = {
|
||||
private def inferView(pos: int, from: Type, name: Name, tp: Type, reportAmbiguous: boolean): Tree = {
|
||||
val to = refinedType(List(WildcardType), NoSymbol)
|
||||
val psym = (if (name.isTypeName) to.symbol.newAbstractType(pos, name)
|
||||
else to.symbol.newValue(pos, name)) setInfo WildcardType
|
||||
else to.symbol.newValue(pos, name)) setInfo tp
|
||||
to.decls.enter(psym)
|
||||
inferView(pos, from, to, reportAmbiguous)
|
||||
}
|
||||
|
|
@ -101,6 +103,10 @@ trait Typers requires Analyzer {
|
|||
val SUPERCONSTRmode = 0x100; // Set for the `super' in a superclass constructor call
|
||||
// super.<init>
|
||||
|
||||
val SNDTRYmode = 0x200; // indicates that an application is typed for the 2nd
|
||||
// time. In that case functions may no longer be
|
||||
// be coerced with implicit views.
|
||||
|
||||
private val stickyModes: int = EXPRmode | PATTERNmode | TYPEmode
|
||||
|
||||
/** Report a type error.
|
||||
|
|
@ -121,7 +127,7 @@ trait Typers requires Analyzer {
|
|||
case _ =>
|
||||
ex.getMessage()
|
||||
}
|
||||
if (settings.debug.value) ex.printStackTrace()
|
||||
//if (settings.debug.value) ex.printStackTrace()//DEBUG
|
||||
if (context.reportGeneralErrors) error(pos, msg)
|
||||
else throw new TypeError(msg)
|
||||
}
|
||||
|
|
@ -369,7 +375,7 @@ trait Typers requires Analyzer {
|
|||
} else if (!tree.symbol.isConstructor && mt.paramTypes.isEmpty) { // (4.3)
|
||||
adapt(typed(Apply(tree, List()) setPos tree.pos), mode, pt)
|
||||
} else {
|
||||
if (context.reportGeneralErrors) {
|
||||
if (context.implicitsEnabled) {
|
||||
if (settings.migrate.value && !tree.symbol.isConstructor && isCompatible(mt, pt))
|
||||
error(tree.pos, migrateMsg + " method can be converted to function only if an expected function type is given");
|
||||
else
|
||||
|
|
@ -451,7 +457,7 @@ trait Typers requires Analyzer {
|
|||
return typed(atPos(tree.pos)(Block(List(tree), Literal(()))), mode, pt)
|
||||
case _ =>
|
||||
}
|
||||
if (context.reportGeneralErrors && !tree.tpe.isError && !pt.isError) {
|
||||
if (context.implicitsEnabled && !tree.tpe.isError && !pt.isError) {
|
||||
// (13); the condition prevents chains of views
|
||||
if (settings.debug.value) log("inferring view from "+tree.tpe+" to "+pt)
|
||||
val coercion = inferView(tree.pos, tree.tpe, pt, true)
|
||||
|
|
@ -470,14 +476,18 @@ trait Typers requires Analyzer {
|
|||
// adapt(tree, mode, pt)
|
||||
// }
|
||||
|
||||
def adaptToName(qual: Tree, name: Name): Tree =
|
||||
def adaptToMember(qual: Tree, name: Name, tp: Type): Tree =
|
||||
if (qual.isTerm && (qual.symbol == null || qual.symbol.isValue) &&
|
||||
!phase.erasedTypes && !qual.tpe.widen.isError &&
|
||||
qual.tpe.nonLocalMember(name) == NoSymbol) {
|
||||
val coercion = inferView(qual.pos, qual.tpe, name, true)
|
||||
if (coercion != EmptyTree) typedQualifier(atPos(qual.pos)(Apply(coercion, List(qual))))
|
||||
!phase.erasedTypes && !qual.tpe.widen.isError) {
|
||||
val coercion = inferView(qual.pos, qual.tpe, name, tp, true)
|
||||
if (coercion != EmptyTree)
|
||||
typedQualifier(atPos(qual.pos)(Apply(coercion, List(qual))))
|
||||
else qual
|
||||
} else qual
|
||||
|
||||
def adaptToName(qual: Tree, name: Name) =
|
||||
if (qual.tpe.nonLocalMember(name) != NoSymbol) qual
|
||||
else adaptToMember(qual, name, WildcardType)
|
||||
|
||||
private def completeParentType(tpt: Tree, tparams: List[Symbol], enclTparams: List[Symbol], vparamss: List[List[ValDef]], superargs: List[Tree]): Type = {
|
||||
enclTparams foreach context.scope.enter
|
||||
|
|
@ -979,11 +989,13 @@ trait Typers requires Analyzer {
|
|||
else this
|
||||
argTyper.typed(arg, mode & stickyModes, pt)
|
||||
}
|
||||
|
||||
def typedArgs(args: List[Tree]) =
|
||||
List.mapConserve(args)(arg => typedArg(arg, WildcardType))
|
||||
|
||||
def typedApply(fun: Tree, args: List[Tree]): Tree = fun.tpe match {
|
||||
case OverloadedType(pre, alts) =>
|
||||
val args1 = List.mapConserve(args)(arg =>
|
||||
typedArg(arg, WildcardType))
|
||||
val args1 = typedArgs(args)
|
||||
inferMethodAlternative(fun, context.undetparams, args1 map (.tpe.deconst), pt)
|
||||
typedApply(adapt(fun, funmode, WildcardType), args1)
|
||||
case MethodType(formals0, restpe) =>
|
||||
|
|
@ -1033,6 +1045,31 @@ trait Typers requires Analyzer {
|
|||
case _ =>
|
||||
errorTree(tree, ""+fun+" does not take parameters")
|
||||
}
|
||||
|
||||
def tryTypedApply(fun: Tree, args: List[Tree]): Tree = {
|
||||
val reportGeneralErrors = context.reportGeneralErrors
|
||||
val reportAmbiguousErrors = context.reportAmbiguousErrors
|
||||
try {
|
||||
context.reportGeneralErrors = false
|
||||
context.reportAmbiguousErrors = false
|
||||
typedApply(fun, args)
|
||||
} catch {
|
||||
case ex: TypeError =>
|
||||
val args1 = typedArgs(args)
|
||||
val Select(qual, name) = fun
|
||||
context.reportGeneralErrors = reportGeneralErrors
|
||||
context.reportAmbiguousErrors = reportAmbiguousErrors
|
||||
val qual1 = adaptToMember(qual, name, MethodType(args1 map (.tpe), pt))
|
||||
if (qual1 eq qual) typedApply(fun, args)
|
||||
else
|
||||
typed1(
|
||||
Apply(Select(qual1, name) setPos fun.pos, args) setPos tree.pos,
|
||||
mode | SNDTRYmode, pt)
|
||||
} finally {
|
||||
context.reportGeneralErrors = reportGeneralErrors
|
||||
context.reportAmbiguousErrors = reportAmbiguousErrors
|
||||
}
|
||||
}
|
||||
|
||||
/** Attribute a selection where `tree' is `qual.name'.
|
||||
* `qual' is already attributed.
|
||||
|
|
@ -1397,7 +1434,11 @@ trait Typers requires Analyzer {
|
|||
fun1 = adapt(fun1 setSymbol sym setType pre.memberType(sym), funmode, WildcardType)
|
||||
}
|
||||
if (util.Statistics.enabled) appcnt = appcnt + 1
|
||||
typedApply(fun1, args)
|
||||
if (xviews &&
|
||||
fun1.isInstanceOf[Select] &&
|
||||
!fun1.tpe.isInstanceOf[ImplicitMethodType] &&
|
||||
(mode & (EXPRmode | SNDTRYmode)) == EXPRmode) tryTypedApply(fun1, args)
|
||||
else typedApply(fun1, args)
|
||||
}
|
||||
|
||||
case Super(qual, mix) =>
|
||||
|
|
@ -1417,7 +1458,7 @@ trait Typers requires Analyzer {
|
|||
else {
|
||||
val ps = clazz.info.parents dropWhile (p => p.symbol.name != mix)
|
||||
if (ps.isEmpty) {
|
||||
System.out.println(clazz.info.parents map (.symbol.name));//debug
|
||||
if (settings.debug.value) System.out.println(clazz.info.parents map (.symbol.name));//debug
|
||||
error(tree.pos, ""+mix+" does not name a base class of "+clazz)
|
||||
ErrorType
|
||||
} else ps.head
|
||||
|
|
@ -1498,7 +1539,7 @@ trait Typers requires Analyzer {
|
|||
errorTree(tree, ""+tpt1.tpe+" does not take type parameters")
|
||||
} else {
|
||||
//System.out.println("\{tpt1}:\{tpt1.symbol}:\{tpt1.symbol.info}")
|
||||
System.out.println(""+tpt1+":"+tpt1.symbol+":"+tpt1.symbol.info);//debug
|
||||
if (settings.debug.value) System.out.println(""+tpt1+":"+tpt1.symbol+":"+tpt1.symbol.info);//debug
|
||||
errorTree(tree, "wrong number of type arguments for "+tpt1.tpe+", should be "+tparams.length)
|
||||
}
|
||||
case _ =>
|
||||
|
|
@ -1694,7 +1735,7 @@ trait Typers requires Analyzer {
|
|||
if (arg != EmptyTree) arg
|
||||
else errorTree(tree, "no implicit argument matching parameter type "+pt+" was found.")
|
||||
}
|
||||
Apply(tree, formals map implicitArg) setPos tree.pos
|
||||
Apply(tree, formals map implicitArg) setPos tree.pos
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue