partition.check

/*****************************************
  Emitting Generated Code                  
*******************************************/
class partitionmapRange extends ((Int, Int)=>(Tuple2ListIntListInt)) {
def apply(x0:Int, x1:Int): Tuple2ListIntListInt = {
var x3: Int = x0
val x2 = List()
var x4: scala.collection.immutable.List[Int] = x2
val x20 = while ({val x5 = x3
val x6 = x5 <= x1
x6}) {
val x8 = x4
val x9 = x3
val x10 = x9 % 2
val x11 = x10 == 0
val x15 = if (x11) {
val x12 = x9 * 2
val x13 = List(x12)
val x14 = x8 ::: x13
x14
} else {
x8
}
x4 = x15
val x17 = x9 + 1
x3 = x17
()
}
val x21 = x4
var x22: Int = x0
var x23: scala.collection.immutable.List[Int] = x2
val x40 = while ({val x24 = x22
val x25 = x24 <= x1
x25}) {
val x27 = x23
val x28 = x22
val x29 = x28 % 2
val x30 = x29 == 0
val x35 = if (x30) {
x27
} else {
val x32 = x28 * 3
val x33 = List(x32)
val x34 = x27 ::: x33
x34
}
x23 = x35
val x37 = x28 + 1
x22 = x37
()
}
val x41 = x23
val x42 = new Tuple2ListIntListInt(x21,x41)
x42
}
}
/*****************************************
  End of Generated Code                  
*******************************************/

case class Tuple2ListIntListInt(_1: scala.collection.immutable.List[Int], _2: scala.collection.immutable.List[Int])
compilation: ok
Tuple2ListIntListInt(List(4, 8, 12, 16, 20),List(3, 9, 15, 21, 27))
/*****************************************
  Emitting Generated Code                  
*******************************************/
class multifoldleftRange extends ((Int, Int)=>(Tuple2ListIntListInt)) {
def apply(x0:Int, x1:Int): Tuple2ListIntListInt = {
var x4: Int = x0
val x2 = List()
val x3 = new Tuple2ListIntListInt(x2,x2)
var x5: Tuple2ListIntListInt = x3
val x25 = while ({val x6 = x4
val x7 = x6 <= x1
x7}) {
val x9 = x5
val x10 = x4
val x11 = x10 % 2
val x12 = x11 == 0
val x20 = if (x12) {
val x14 = x9._2
val x13 = x9._1
val x15 = List(x10)
val x16 = x13 ::: x15
val x17 = new Tuple2ListIntListInt(x16,x14)
x17
} else {
val x13 = x9._1
val x14 = x9._2
val x15 = List(x10)
val x18 = x14 ::: x15
val x19 = new Tuple2ListIntListInt(x13,x18)
x19
}
x5 = x20
val x22 = x10 + 1
x4 = x22
()
}
val x26 = x5
x26
}
}
/*****************************************
  End of Generated Code                  
*******************************************/
compilation: ok
Tuple2ListIntListInt(List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))
/*****************************************
  Emitting Generated Code                  
*******************************************/
class partitionbis extends ((Int, Int)=>(scala.collection.immutable.List[EitherIntInt])) {
def apply(x0:Int, x1:Int): scala.collection.immutable.List[EitherIntInt] = {
var x3: Int = x0
val x2 = List()
var x4: scala.collection.immutable.List[EitherIntInt] = x2
val x23 = while ({val x5 = x3
val x6 = x5 <= x1
x6}) {
val x8 = x4
val x9 = x3
val x10 = x9 % 2
val x11 = x10 == 0
val x18 = if (x11) {
val x12 = new EitherIntInt(x9,0,true)
val x13 = List(x12)
val x14 = x8 ::: x13
x14
} else {
val x15 = new EitherIntInt(0,x9,false)
val x16 = List(x15)
val x17 = x8 ::: x16
x17
}
x4 = x18
val x20 = x9 + 1
x3 = x20
()
}
val x24 = x4
x24
}
}
/*****************************************
  End of Generated Code                  
*******************************************/
compilation: ok
List(EitherIntInt(0,1,false), EitherIntInt(2,0,true), EitherIntInt(0,3,false), EitherIntInt(4,0,true), EitherIntInt(0,5,false), EitherIntInt(6,0,true), EitherIntInt(0,7,false), EitherIntInt(8,0,true), EitherIntInt(0,9,false), EitherIntInt(10,0,true))
/*****************************************
  Emitting Generated Code                  
*******************************************/
class partitionbismap extends ((Int, Int)=>(scala.collection.immutable.List[EitherIntInt])) {
def apply(x0:Int, x1:Int): scala.collection.immutable.List[EitherIntInt] = {
var x3: Int = x0
val x2 = List()
var x4: scala.collection.immutable.List[EitherIntInt] = x2
val x27 = while ({val x5 = x3
val x6 = x5 <= x1
x6}) {
val x8 = x4
val x9 = x3
val x10 = x9 % 2
val x11 = x10 == 0
val x22 = if (x11) {
val x13 = x9 * 2
val x14 = new EitherIntInt(x13,0,true)
val x15 = List(x14)
val x16 = x8 ::: x15
x16
} else {
val x18 = x9 * 3
val x19 = new EitherIntInt(0,x18,false)
val x20 = List(x19)
val x21 = x8 ::: x20
x21
}
x4 = x22
val x24 = x9 + 1
x3 = x24
()
}
val x28 = x4
x28
}
}
/*****************************************
  End of Generated Code                  
*******************************************/
compilation: ok
List(EitherIntInt(0,3,false), EitherIntInt(4,0,true), EitherIntInt(0,9,false), EitherIntInt(8,0,true), EitherIntInt(0,15,false), EitherIntInt(12,0,true), EitherIntInt(0,21,false), EitherIntInt(16,0,true), EitherIntInt(0,27,false), EitherIntInt(20,0,true))
/*****************************************
  Emitting Generated Code                  
*******************************************/
class partitionbismap2listpair extends ((Int, Int)=>(Tuple2ListIntListInt)) {
def apply(x0:Int, x1:Int): Tuple2ListIntListInt = {
var x4: Int = x0
val x2 = List()
val x3 = new Tuple2ListIntListInt(x2,x2)
var x5: Tuple2ListIntListInt = x3
val x32 = while ({val x6 = x4
val x7 = x6 <= x1
x7}) {
val x9 = x5
val x10 = x4
val x11 = x10 % 2
val x12 = x11 == 0
val x27 = if (x12) {
val x17 = x9._2
val x16 = x9._1
val x14 = x10 * 2
val x18 = List(x14)
val x19 = x16 ::: x18
val x20 = new Tuple2ListIntListInt(x19,x17)
x20
} else {
val x16 = x9._1
val x17 = x9._2
val x22 = x10 * 3
val x24 = List(x22)
val x25 = x17 ::: x24
val x26 = new Tuple2ListIntListInt(x16,x25)
x26
}
x5 = x27
val x29 = x10 + 1
x4 = x29
()
}
val x33 = x5
x33
}
}
/*****************************************
  End of Generated Code                  
*******************************************/
compilation: ok
Tuple2ListIntListInt(List(4, 8, 12, 16, 20),List(3, 9, 15, 21, 27))
/*****************************************
  Emitting Generated Code                  
*******************************************/
class groupwithsum extends ((Int, Int)=>(scala.collection.immutable.HashMap[Int, Int])) {
def apply(x0:Int, x1:Int): scala.collection.immutable.HashMap[Int, Int] = {
var x3: Int = x0
val x2 = collection.immutable.HashMap[Int,Int]()
var x4: scala.collection.immutable.HashMap[Int, Int] = x2
val x22 = while ({val x5 = x3
val x6 = x5 <= x1
x6}) {
val x8 = x4
val x9 = x3
val x10 = x9 % 3
val x12 = x8.contains(x10)
val x17 = if (x12) {
val x13 = x8(x10)
val x14 = x13 + x9
val x15 = x8.updated(x10, x14).asInstanceOf[collection.immutable.HashMap[Int,Int]]
x15
} else {
val x16 = x8.updated(x10, x9).asInstanceOf[collection.immutable.HashMap[Int,Int]]
x16
}
x4 = x17
val x19 = x9 + 1
x3 = x19
()
}
val x23 = x4
x23
}
}
/*****************************************
  End of Generated Code                  
*******************************************/
compilation: ok
Map(0 -> 18, 1 -> 22, 2 -> 15)
/*****************************************
  Emitting Generated Code                  
*******************************************/
class partitioncpsmap2listpair extends ((Int, Int)=>(Tuple2ListIntListInt)) {
def apply(x0:Int, x1:Int): Tuple2ListIntListInt = {
var x4: Int = x0
val x2 = List()
val x3 = new Tuple2ListIntListInt(x2,x2)
var x5: Tuple2ListIntListInt = x3
val x44 = while ({val x6 = x4
val x7 = x6 <= x1
x7}) {
val x9 = x5
val x10 = x4
var x13: Int = 0
var x14: Int = 0
var x15: Boolean = true
val x11 = x10 % 2
val x12 = x11 == 0
val x25 = if (x12) {
x13 = x10
x14 = 0
x15 = true
()
} else {
x13 = 0
x14 = x10
x15 = false
()
}
val x26 = x13
val x27 = x14
val x28 = x15
val x39 = if (x28) {
val x31 = x9._2
val x30 = x9._1
val x29 = x26 * 2
val x32 = List(x29)
val x33 = x30 ::: x32
val x34 = new Tuple2ListIntListInt(x33,x31)
x34
} else {
val x30 = x9._1
val x31 = x9._2
val x35 = x27 * 3
val x36 = List(x35)
val x37 = x31 ::: x36
val x38 = new Tuple2ListIntListInt(x30,x37)
x38
}
x5 = x39
val x41 = x10 + 1
x4 = x41
()
}
val x45 = x5
x45
}
}
/*****************************************
  End of Generated Code                  
*******************************************/
compilation: ok
Tuple2ListIntListInt(List(4, 8, 12, 16, 20),List(3, 9, 15, 21, 27))