95 lines
2.2 KiB
Plaintext
95 lines
2.2 KiB
Plaintext
import mem
|
|
import vector
|
|
|
|
fun max<T>(a: T, b: T): T {
|
|
if (a > b)
|
|
return a;
|
|
return b;
|
|
}
|
|
|
|
fun min<T>(a: T, b: T): T {
|
|
if (a > b)
|
|
return b;
|
|
return a;
|
|
}
|
|
|
|
fun make_pair<T,U>(first: T, second: U): pair<T,U> {
|
|
var it.construct(first, second): pair<T,U>
|
|
return it
|
|
}
|
|
|
|
obj pair<T,U> (Object) {
|
|
var first: T
|
|
var second: U
|
|
|
|
fun construct(firstIn: T, secondIn: U): *pair<T,U> {
|
|
mem::maybe_copy_construct(&first, &firstIn)
|
|
mem::maybe_copy_construct(&second, &secondIn)
|
|
return this
|
|
}
|
|
|
|
fun construct(): *pair<T,U> {
|
|
mem::maybe_construct(&first)
|
|
mem::maybe_construct(&second)
|
|
return this
|
|
}
|
|
|
|
fun copy_construct(old: *pair<T,U>):void {
|
|
mem::maybe_copy_construct(&first, &old->first)
|
|
mem::maybe_copy_construct(&second, &old->second)
|
|
}
|
|
|
|
fun destruct():void {
|
|
mem::maybe_destruct(&first)
|
|
mem::maybe_destruct(&second)
|
|
}
|
|
|
|
// the old unnecessary template to prevent generation
|
|
// if not used trick (in this case, changing out U with V)
|
|
fun operator==<V>(other: ref pair<T,V>): bool {
|
|
return first == other.first && second == other.second
|
|
}
|
|
}
|
|
|
|
fun range(end:int): range {
|
|
var toRet.construct(0, end, 1): range
|
|
return toRet
|
|
}
|
|
|
|
fun range(begin: int, end:int): range {
|
|
var toRet.construct(begin, end, 1): range
|
|
return toRet
|
|
}
|
|
fun range(begin: int, end:int, step: int): range {
|
|
var toRet.construct(begin, end, step): range
|
|
return toRet
|
|
}
|
|
|
|
obj range {
|
|
var begin: int
|
|
var end: int
|
|
var step: int
|
|
fun construct(beginIn: int, endIn: int, stepIn: int) : *range {
|
|
begin = beginIn
|
|
end = endIn
|
|
step = stepIn
|
|
}
|
|
fun for_each(func: fun(int):void):void {
|
|
for (var i = begin; i < end; i+= step;)
|
|
func(i)
|
|
}
|
|
fun map<T>(func: fun(int): T): vector::vector<T> {
|
|
var ret.construct( (end-begin)/step + 1 ) : vector::vector<T>
|
|
for (var i = begin; i < end; i+= step;)
|
|
ret.addEnd(func(i))
|
|
return ret
|
|
}
|
|
fun any_true(func: fun(int):bool):bool {
|
|
for (var i = begin; i < end; i+= step;)
|
|
if (func(i))
|
|
return true
|
|
return false
|
|
}
|
|
}
|
|
|