Category talk:Wren-long: Difference between revisions

However, some tasks on RC only require integers within the 64-bit range and ''BigInt'' feels like overkill for such tasks.

 

 

 

The design of ''ULong'' follows closely that of the ''BigInt'' class though the implementation is generally much simpler and hopefully more performant for numbers within its range.

 

The most obvious way to perform division of larger numbers is to first obtain an estimate of the result by treating them as ''Num''s and then refine this result iteratively until the exact result is obtained. However, this is easier said than done because the accuracy of the initial estimate will depend on the magnitude of the numbers and one has to guard against overflow when performing the iterations. Consequently, this is quite a ''slow'' operation.

 

===Source code===

 

 

/*

static four { lohi_( 4, 0) }

static five { lohi_( 5, 0) }

static ten { lohi_(10, 0) }

 

// Returns the largest ULong = 2^64-1 = 18446744073709551615

static largest { lohi_(4294967295, 4294967295) }

 

// Returns the smallest ULong = 0

static smallest { lohi_(0, 0) }

 

static isShort_(n) { (n is Num) && n.isInteger && n >= 0 && n <= 4294967295 }

// Private method to determine whether a number is a small unsigned integer or not.

static isSmall_(n) { (n is Num) && n.isInteger && n >= 0 && n <= 9007199254740991 }

 

// Private method to calculate the base 2 logarithm of a number.

return String.fromCodePoint((c >= 65 && c <= 90) ? c + 32 : c)

}.join() }

 

// Private helper method to convert a lower case base string to a small integer.

if (!(b is ULong)) b = new(b)

return (a < b) ? a : b

}

 

if (!(a is ULong)) a = new(a)

if (!(b is ULong)) b = new(b)

return a / gcd(a, b) * b

}

if (n < 2) return one

var fact = one

while (i <= n) {

fact = fact * i

return fact

}

 

// Returns whether or not 'n' is an instance of ULong.

static isInstance(n) { n is ULong }

 

}

 

var next = false

while (d != 0) {

if (x.isOne) return false

if (x == nPrev) {

}

 

// If 'v' is not small, will probably lose accuracy.

if (v < 0 || v.isNan) return ULong.zero

var m = 4294967296 // 2 ^ 32

}

 

// Scientific notation is permitted.

// Raises an error if the result is out of bounds.

v = v.trim()

if (v.count == 0 || v[0] == "-") Fiber.abort("Invalid unsigned integer.")

// Scientific notation is not permitted.

// Wraps out of range values.

if (!(v is String)) Fiber.abort("Value must be a numeric string in the given base.")

if (!((base is Num) && base.isInteger && base >= 2 && base <= 36)) {

}

 

static new(value) {

}

}

 

// Returns true if 'n' is a divisor of the current instance, false otherwise

isDivisibleBy(n) { (this % n).isZero }

 

// Returns true if the current instance is prime, false otherwise.

isPrime {

}

 

msb_ {

if (_hi == 0) return (_lo > 0) ? ULong.log2_(_lo).floor : 0

return ULong.log2_(_hi).floor + 32

}

}

 

var div = ULong.zero

var rem = this.copy()

}

return [div, rem]

}

 

// Divides the current instance by a ULong.

 

// Returns the remainder after dividing the current instance by a ULong.

 

//Returns the bitwise 'and' of the current instance and another ULong.

min(n) { ULong.min(this, n) }

 

// If it's more than max, max is returned. Otherwise, this instance is returned.

clamp(a, b) {

// Squares the current instance. Wraps on overflow.

square { this * this }

 

// Returns the integer square root of the current instance i.e. the largest integer 'x0'

// such that x0.square <= this.

isqrt {

// otherwise use Newton's method

var x0 = this >> 1

}

return y

}

 

while (!exp.isZero) {

if (base.isZero) return ULong.zero

exp = exp >> 1

}

return r

}

 

// Expresses the current instance as a list of 8 unsigned bytes in little-endian format.

toBytes {

_hi & 0xff, _hi >> 8 & 0xff, _hi >> 16 & 0xff, _hi >> 24]

}

 

// Private worker method for toBaseString, toHexString and toString.

// Returns the string representation of the current instance in base 10.

toString { toBaseString_(10) }

}

 

static sum(a) { a.reduce(ULong.zero) { |acc, x| acc + x } }

static mean(a) { sum(a)/a.count }

static max(a) { a.reduce { |acc, x| (x > acc) ? x : acc } }

static min(a) { a.reduce { |acc, x| (x < acc) ? x : acc } }

}