Add more rings

nicolasstucki · nicolasstucki · commit 98606aad6669 · 2018-06-28T21:45:18.000+02:00
diff --git a/tests/run-with-compiler/shonan-hmm-simple.check b/tests/run-with-compiler/shonan-hmm-simple.check
@@ -1,14 +1,54 @@
-21
-Complex(7,9)
-0.+(1.*(1)).+(2.*(0)).+(4.*(1)).+(8.*(0)).+(16.*(1))
-{
-  val arr3: scala.Array[scala.Int] = scala.Array.apply(1, 2, 4, 8, 16)
-  val arr4: scala.Array[scala.Int] = scala.Array.apply(1, 0, 1, 0, 1)
+10
+
+Complex(3,2)
+
+0.+(0.*(1)).+(1.*(0)).+(2.*(1)).+(4.*(0)).+(8.*(1))
+10
+
+((arr1: scala.Array[scala.Int], arr2: scala.Array[scala.Int]) => {
+  dotty.DottyPredef.assert(arr1.length.==(arr2.length))
   var sum: scala.Int = 0
-  scala.Predef.intWrapper(0).until(scala.Predef.intArrayOps(arr3).size).foreach[scala.Unit](((i: scala.Int) => sum = sum.+(arr3.apply(i).*(arr4.apply(i)))))
+  var i: scala.Int = 0
+  while (i.<(scala.Predef.intArrayOps(arr1).size)) {
+    sum = sum.+(arr1.apply(i).*(arr2.apply(i)))
+    i = i.+(1)
+  }
   (sum: scala.Int)
-}
-{
-  val arr3: scala.Array[scala.Int] = scala.Array.apply(1, 2, 4, 8, 16)
-  arr3.apply(0).+(arr3.apply(2)).+(arr3.apply(4))
-}
+})
+10
+
+0.+(2).+(8)
+10
+
+((arr: scala.Array[scala.Int]) => {
+  dotty.DottyPredef.assert(arr.length.==(5))
+  arr.apply(0).+(arr.apply(2)).+(arr.apply(4))
+})
+10
+
+((arr: scala.Array[Complex[scala.Int]]) => {
+  dotty.DottyPredef.assert(arr.length.==(4))
+  Complex.apply[scala.Int]({
+    Complex.apply[scala.Int](arr.apply(0).re.*({
+      Complex.apply[scala.Int](0, 1)
+    }.re).-(arr.apply(0).im.*({
+      Complex.apply[scala.Int](0, 1)
+    }.im)), arr.apply(0).re.*({
+      Complex.apply[scala.Int](0, 1)
+    }.im).+(arr.apply(0).im.*({
+      Complex.apply[scala.Int](0, 1)
+    }.re)))
+  }.re.+(arr.apply(3).re), {
+    Complex.apply[scala.Int](arr.apply(0).re.*({
+      Complex.apply[scala.Int](0, 1)
+    }.re).-(arr.apply(0).im.*({
+      Complex.apply[scala.Int](0, 1)
+    }.im)), arr.apply(0).re.*({
+      Complex.apply[scala.Int](0, 1)
+    }.im).+(arr.apply(0).im.*({
+      Complex.apply[scala.Int](0, 1)
+    }.re)))
+  }.im.+(arr.apply(3).im))
+})
+Complex(3,2)
+
diff --git a/tests/run-with-compiler/shonan-hmm-simple.scala b/tests/run-with-compiler/shonan-hmm-simple.scala
@@ -10,26 +10,34 @@ trait Ring[T] {
 
 class RingInt extends Ring[Int] {
   val zero = 0
-  val one = 1
-  val add = (x, y) => x + y
+  val one  = 1
+  val add  = (x, y) => x + y
   val sub  = (x, y) => x - y
   val mul  = (x, y) => x * y
 }
 
 class RingIntExpr extends Ring[Expr[Int]] {
   val zero = '(0)
-  val one = '(1)
-  val add = (x, y) => '(~x + ~y)
+  val one  = '(1)
+  val add  = (x, y) => '(~x + ~y)
   val sub  = (x, y) => '(~x - ~y)
   val mul  = (x, y) => '(~x * ~y)
 }
 
 class RingComplex[U](u: Ring[U]) extends Ring[Complex[U]] {
   val zero = Complex(u.zero, u.zero)
   val one  = Complex(u.one, u.zero)
-  val add = (x, y) => Complex(u.add(x.re, y.re), u.add(x.im, y.im))
-  val sub = (x, y) => Complex(u.sub(x.re, y.re), u.sub(x.im, y.im))
-  val mul = (x, y) => Complex(u.sub(u.mul(x.re, y.re), u.mul(x.im, y.im)), u.add(u.mul(x.re, y.im), u.mul(x.im, y.re)))
+  val add  = (x, y) => Complex(u.add(x.re, y.re), u.add(x.im, y.im))
+  val sub  = (x, y) => Complex(u.sub(x.re, y.re), u.sub(x.im, y.im))
+  val mul  = (x, y) => Complex(u.sub(u.mul(x.re, y.re), u.mul(x.im, y.im)), u.add(u.mul(x.re, y.im), u.mul(x.im, y.re)))
+}
+
+class RingComplexExpr[U: Type](u: Ring[Expr[U]]) extends Ring[Expr[Complex[U]]] {
+  val zero = '(Complex(~u.zero, ~u.zero))
+  val one  = '(Complex(~u.one, ~u.zero))
+  val add  = (x, y) => '(Complex(~u.add('((~x).re), '((~y).re)), ~u.add('((~x).im), '((~y).im))))
+  val sub  = (x, y) => '(Complex(~u.sub('((~x).re), '((~y).re)), ~u.sub('((~x).im), '((~y).im))))
+  val mul  = (x, y) => '(Complex(~u.sub(u.mul('((~x).re), '((~y).re)), u.mul('((~x).im), '((~y).im))), ~u.add(u.mul('((~x).re), '((~y).im)), u.mul('((~x).im), '((~y).re)))))
 }
 
 sealed trait PV[T] {
@@ -42,43 +50,48 @@ case class Dyn[T](x: Expr[T]) extends PV[T] {
   def expr(implicit l: Liftable[T]): Expr[T] = x
 }
 
-case class RingPV[U: Liftable](staRing: Ring[U], dynRing: Ring[Expr[U]]) extends Ring[PV[U]] {
-  type T = PV[U]
-
-  import staRing._
-  import dynRing._
-
-  val zero: T = Sta(staRing.zero)
-  val one: T = Sta(staRing.one)
-  val add = (x: T, y: T) => (x, y) match {
-    case (Sta(staRing.zero), x) => x
-    case (x, Sta(staRing.zero)) => x
-    case (Sta(x), Sta(y)) => Sta(staRing.add(x, y))
-    case (x, y) => Dyn(dynRing.add(x.expr, y.expr))
+class RingPV[U: Liftable](u: Ring[U], eu: Ring[Expr[U]]) extends Ring[PV[U]] {
+  val zero: PV[U] = Sta(u.zero)
+  val one: PV[U] = Sta(u.one)
+  val add = (x: PV[U], y: PV[U]) => (x, y) match {
+    case (Sta(u.zero), x) => x
+    case (x, Sta(u.zero)) => x
+    case (Sta(x), Sta(y)) => Sta(u.add(x, y))
+    case (x, y) => Dyn(eu.add(x.expr, y.expr))
   }
-  val sub = (x: T, y: T) => (x, y) match {
-    case (Sta(staRing.zero), x) => x
-    case (x, Sta(staRing.zero)) => x
-    case (Sta(x), Sta(y)) => Sta(staRing.sub(x, y))
-    case (x, y) => Dyn(dynRing.sub(x.expr, y.expr))
+  val sub = (x: PV[U], y: PV[U]) => (x, y) match {
+    case (Sta(u.zero), x) => x
+    case (x, Sta(u.zero)) => x
+    case (Sta(x), Sta(y)) => Sta(u.sub(x, y))
+    case (x, y) => Dyn(eu.sub(x.expr, y.expr))
   }
-  val mul = (x: T, y: T) => (x, y) match {
-    case (Sta(staRing.zero), _) => Sta(staRing.zero)
-    case (_, Sta(staRing.zero)) => Sta(staRing.zero)
-    case (Sta(staRing.one), x) => x
-    case (x, Sta(staRing.one)) => x
-    case (Sta(x), Sta(y)) => Sta(staRing.mul(x, y))
-    case (x, y) => Dyn(dynRing.mul(x.expr, y.expr))
+  val mul = (x: PV[U], y: PV[U]) => (x, y) match {
+    case (Sta(u.zero), _) => Sta(u.zero)
+    case (_, Sta(u.zero)) => Sta(u.zero)
+    case (Sta(u.one), x) => x
+    case (x, Sta(u.one)) => x
+    case (Sta(x), Sta(y)) => Sta(u.mul(x, y))
+    case (x, y) => Dyn(eu.mul(x.expr, y.expr))
   }
 }
 
+
 case class Complex[T](re: T, im: T)
 
+object Complex {
+  implicit def isLiftable[T: Type: Liftable]: Liftable[Complex[T]] = new Liftable[Complex[T]] {
+    def toExpr(comp: Complex[T]): Expr[Complex[T]] = '(Complex(~comp.re.toExpr, ~comp.im.toExpr))
+  }
+}
+
 case class Vec[Idx, T](size: Idx, get: Idx => T) {
   def map[U](f: T => U): Vec[Idx, U] = Vec(size, i => f(get(i)))
   def zipWith[U, V](other: Vec[Idx, U], f: (T, U) => V): Vec[Idx, V] = Vec(size, i => f(get(i), other.get(i)))
 }
 
+object Vec {
+  def from[T](elems: T*): Vec[Int, T] = new Vec(elems.size, i => elems(i))
+}
 
 trait VecOps[Idx, T] {
   val reduce: ((T, T) => T, T, Vec[Idx, T]) => T
@@ -93,20 +106,14 @@ class StaticVecOps[T] extends VecOps[Int, T] {
   }
 }
 
-class StaticVecOptOps[T] extends VecOps[Int, T] {
-  val reduce: ((T, T) => T, T, Vec[Int, T]) => T = (plus, zero, vec) => {
-    var sum = zero
-    for (i <- 0 until vec.size)
-      sum = plus(sum, vec.get(i))
-    sum
-  }
-}
-
 class ExprVecOps[T: Type] extends VecOps[Expr[Int], Expr[T]] {
   val reduce: ((Expr[T], Expr[T]) => Expr[T], Expr[T], Vec[Expr[Int], Expr[T]]) => Expr[T] = (plus, zero, vec) => '{
     var sum = ~zero
-    for (i <- 0 until ~vec.size)
+    var i = 0
+    while (i < ~vec.size) {
       sum = ~{ plus('(sum), vec.get('(i))) }
+      i += 1
+    }
     sum
   }
 }
@@ -120,60 +127,94 @@ object Test {
   implicit val toolbox: scala.quoted.Toolbox = dotty.tools.dotc.quoted.Toolbox.make
 
   def main(args: Array[String]): Unit = {
-    val arr1 = Array(1, 2, 4, 8, 16)
+    val arr1 = Array(0, 1, 2, 4, 8)
     val arr2 = Array(1, 0, 1, 0, 1)
+    val cmpxArr1 = Array(Complex(1, 0), Complex(2, 3), Complex(0, 2), Complex(3, 1))
+    val cmpxArr2 = Array(Complex(0, 1), Complex(0, 0), Complex(0, 0), Complex(1, 0))
 
     val vec1 = new Vec(arr1.size, i => arr1(i))
     val vec2 = new Vec(arr2.size, i => arr2(i))
+    val cmpxVec1 = new Vec(cmpxArr1.size, i => cmpxArr1(i))
+    val cmpxVec2 = new Vec(cmpxArr2.size, i => cmpxArr2(i))
+
     val blasInt = new Blas1(new RingInt, new StaticVecOps)
-    println(blasInt.dot(vec1, vec2))
+    val res1 = blasInt.dot(vec1, vec2)
+    println(res1)
+    println()
 
-    val vec3 = new Vec(arr1.size, i => Complex(2, arr2(i)))
-    val vec4 = new Vec(arr2.size, i => Complex(1, arr2(i)))
     val blasComplexInt = new Blas1(new RingComplex(new RingInt), new StaticVecOps)
-    println(blasComplexInt.dot(vec3, vec4))
+    val res2 = blasComplexInt.dot(
+      cmpxVec1,
+      cmpxVec2
+    )
+    println(res2)
+    println()
 
-    val vec5 = new Vec(5, i => arr1(i).toExpr)
-    val vec6 = new Vec(5, i => arr2(i).toExpr)
     val blasStaticIntExpr = new Blas1(new RingIntExpr, new StaticVecOps)
-    println(blasStaticIntExpr.dot(vec5, vec6).show)
-
-
-
-    val code = '{
-      val arr3 = Array(1, 2, 4, 8, 16)
-      val arr4 = Array(1, 0, 1, 0, 1)
-      ~{
-        val vec7 = new Vec('(arr3.size), i => '(arr3(~i)))
-        val vec8 = new Vec('(arr4.size), i => '(arr4(~i)))
-        val blasExprIntExpr = new Blas1(new RingIntExpr, new ExprVecOps)
-        blasExprIntExpr.dot(vec7, vec8)
-      }
-
+    val resCode1 = blasStaticIntExpr.dot(
+      vec1.map(_.toExpr),
+      vec2.map(_.toExpr)
+    )
+    println(resCode1.show)
+    println(resCode1.run)
+    println()
+
+    val blasExprIntExpr = new Blas1(new RingIntExpr, new ExprVecOps)
+    val resCode2: Expr[(Array[Int], Array[Int]) => Int] = '{
+      (arr1, arr2) =>
+        assert(arr1.length == arr2.length)
+        ~{
+          blasExprIntExpr.dot(
+            new Vec('(arr1.size), i => '(arr1(~i))),
+            new Vec('(arr2.size), i => '(arr2(~i)))
+          )
+        }
     }
-    println(code.show)
-
+    println(resCode2.show)
+    println(resCode2.run.apply(arr1, arr2))
+    println()
+
+    val blasStaticIntPVExpr = new Blas1(new RingPV[Int](new RingInt, new RingIntExpr), new StaticVecOps)
+    val resCode3 = blasStaticIntPVExpr.dot(
+      vec1.map(i => Dyn(i.toExpr)),
+      vec2.map(i => Sta(i))
+    ).expr
+    println(resCode3.show)
+    println(resCode3.run)
+    println()
+
+    val blasExprIntPVExpr = new Blas1(new RingPV[Int](new RingInt, new RingIntExpr), new StaticVecOps)
+    val resCode4: Expr[Array[Int] => Int] = '{
+      arr =>
+        assert(arr.length == ~vec2.size.toExpr)
+        ~{
+          blasExprIntPVExpr.dot(
+            new Vec(vec2.size, i => Dyn('(arr(~i.toExpr)))),
+            vec2.map(i => Sta(i))
+          ).expr
+        }
 
-    {
-      val vec5 = new Vec[Int, PV[Int]](5, i => Dyn(arr1(i).toExpr))
-      val vec6 = new Vec[Int, PV[Int]](5, i => Sta(arr2(i)))
-      val blasStaticIntExpr = new Blas1(new RingPV[Int](new RingInt, new RingIntExpr), new StaticVecOps)
-      blasStaticIntExpr.dot(vec5, vec6).expr.show
     }
-
-    {
-      val code = '{
-        val arr3 = Array(1, 2, 4, 8, 16)
+    println(resCode4.show)
+    println(resCode4.run.apply(arr1))
+    println()
+
+    import Complex.isLiftable
+    val blasExprComplexIntPVExpr = new Blas1(new RingPV(new RingComplex(new RingInt), new RingComplexExpr(new RingIntExpr)), new StaticVecOps)
+    val resCode5: Expr[Array[Complex[Int]] => Complex[Int]] = '{
+      arr =>
+        assert(arr.length == ~cmpxVec2.size.toExpr)
         ~{
-          val vec7 = new Vec[Int, PV[Int]](5, i => Dyn('(arr3(~i.toExpr))))
-          val vec8 = new Vec[Int, PV[Int]](5, i => Sta(arr2(i)))
-          val blasExprIntExpr = new Blas1(new RingPV[Int](new RingInt, new RingIntExpr), new StaticVecOps)
-          blasExprIntExpr.dot(vec7, vec8).expr
+          blasExprComplexIntPVExpr.dot(
+            new Vec(cmpxVec2.size, i => Dyn('(arr(~i.toExpr)))),
+            cmpxVec2.map(i => Sta(i))
+          ).expr
         }
-
-      }
-      println(code.show)
     }
+    println(resCode5.show)
+    println(resCode5.run.apply(cmpxArr1))
+    println()
+
   }
 
 }
