YAPC::EU 2018 Glasgow Update!

Task/Quaternion-type/Haskell/quaternion-type-1.hs

@@ -1,8 +1,10 @@
-import Control.Monad
-import Control.Arrow
-import Data.List
+import Control.Monad (join)
 
-data Quaternion = Q Double Double Double Double
+data Quaternion =
+  Q Double
+    Double
+    Double
+    Double
   deriving (Show, Ord, Eq)
 
 realQ :: Quaternion -> Double
@@ -11,23 +13,29 @@ realQ (Q r _ _ _) = r
 imagQ :: Quaternion -> [Double]
 imagQ (Q _ i j k) = [i, j, k]
 
+quaternionFromScalar :: Double -> Quaternion
 quaternionFromScalar s = Q s 0 0 0
 
-listFromQ (Q a b c d) = [a,b,c,d]
+listFromQ :: Quaternion -> [Double]
+listFromQ (Q a b c d) = [a, b, c, d]
+
+quaternionFromList :: [Double] -> Quaternion
 quaternionFromList [a, b, c, d] = Q a b c d
 
 addQ, subQ, mulQ :: Quaternion -> Quaternion -> Quaternion
-addQ (Q a b c d) (Q p q r s) = Q (a+p) (b+q) (c+r) (d+s)
+addQ (Q a b c d) (Q p q r s) = Q (a + p) (b + q) (c + r) (d + s)
 
-subQ (Q a b c d) (Q p q r s) = Q (a-p) (b-q) (c-r) (d-s)
+subQ (Q a b c d) (Q p q r s) = Q (a - p) (b - q) (c - r) (d - s)
 
 mulQ (Q a b c d) (Q p q r s) =
-  Q  (a*p - b*q - c*r - d*s)
-     (a*q + b*p + c*s - d*r)
-     (a*r - b*s + c*p + d*q)
-     (a*s + b*r - c*q + d*p)
+  Q
+    (a * p - b * q - c * r - d * s)
+    (a * q + b * p + c * s - d * r)
+    (a * r - b * s + c * p + d * q)
+    (a * s + b * r - c * q + d * p)
 
-normQ  = sqrt. sum. join (zipWith (*)). listFromQ
+normQ :: Quaternion -> Double
+normQ = sqrt . sum . join (zipWith (*)) . listFromQ
 
 conjQ, negQ :: Quaternion -> Quaternion
 conjQ (Q a b c d) = Q a (-b) (-c) (-d)

Task/Quaternion-type/Haskell/quaternion-type-2.hs

@@ -1,4 +1,43 @@
-[q,q1,q2] = map quaternionFromList [[1..4],[2..5],[3..6]]
--- a*b == b*a
-test :: Quaternion -> Quaternion -> Bool
-test a b =  a `mulQ` b == b `mulQ` a
+class Quaternion(a, b, c, d)
+
+  method norm ()
+    return sqrt (a*a + b*b + c*c + d*d)
+  end
+
+  method negative ()
+    return Quaternion(-a, -b, -c, -d)
+  end
+
+  method conjugate ()
+    return Quaternion(a, -b, -c, -d)
+  end
+
+  method add (n)
+    if type(n) == "Quaternion__state"
+      then return Quaternion(a+n.a, b+n.b, c+n.c, d+n.d)
+      else return Quaternion(a+n, b, c, d)
+  end
+
+  method multiply (n)
+    if type(n) == "Quaternion__state"
+      then return Quaternion(a*n.a - b*n.b - c*n.c - d*n.d,
+                             a*n.b + b*n.a + c*n.d - d*n.c,
+                             a*n.c - b*n.d + c*n.a + d*n.b,
+                             a*n.d + b*n.c - c*n.b + d*n.a)
+      else return Quaternion(a*n, b*n, c*n, d*n)
+  end
+
+  method sign (n)
+    return if n >= 0 then "+" else "-"
+  end
+
+  method string ()
+    return ("" || a || sign(b) || abs(b) || "i" || sign(c) || abs(c) || "j" || sign(d) || abs(d) || "k");
+  end
+
+  initially(a, b, c, d)
+    self.a := if /a then 0 else a
+    self.b := if /b then 0 else b
+    self.c := if /c then 0 else c
+    self.d := if /d then 0 else d
+end

Task/Quaternion-type/Haskell/quaternion-type-3.hs

@@ -1,43 +1,16 @@
-class Quaternion(a, b, c, d)
+procedure main ()
+  q := Quaternion (1,2,3,4)
+  q1 := Quaternion (2,3,4,5)
+  q2 := Quaternion (3,4,5,6)
+  r := 7
 
-  method norm ()
-    return sqrt (a*a + b*b + c*c + d*d)
-  end
-
-  method negative ()
-    return Quaternion(-a, -b, -c, -d)
-  end
-
-  method conjugate ()
-    return Quaternion(a, -b, -c, -d)
-  end
-
-  method add (n)
-    if type(n) == "Quaternion__state"
-      then return Quaternion(a+n.a, b+n.b, c+n.c, d+n.d)
-      else return Quaternion(a+n, b, c, d)
-  end
-
-  method multiply (n)
-    if type(n) == "Quaternion__state"
-      then return Quaternion(a*n.a - b*n.b - c*n.c - d*n.d,
-                             a*n.b + b*n.a + c*n.d - d*n.c,
-                             a*n.c - b*n.d + c*n.a + d*n.b,
-                             a*n.d + b*n.c - c*n.b + d*n.a)
-      else return Quaternion(a*n, b*n, c*n, d*n)
-  end
-
-  method sign (n)
-    return if n >= 0 then "+" else "-"
-  end
-
-  method string ()
-    return ("" || a || sign(b) || abs(b) || "i" || sign(c) || abs(c) || "j" || sign(d) || abs(d) || "k");
-  end
-
-  initially(a, b, c, d)
-    self.a := if /a then 0 else a
-    self.b := if /b then 0 else b
-    self.c := if /c then 0 else c
-    self.d := if /d then 0 else d
+  write ("The norm      of " || q.string() || " is " || q.norm ())
+  write ("The negative  of " || q.string() || " is " || q.negative().string ())
+  write ("The conjugate of " || q.string() || " is " || q.conjugate().string ())
+  write ("Sum of " || q.string() || " and " || r || " is " || q.add(r).string ())
+  write ("Sum of " || q.string() || " and " || q1.string() || " is " || q.add(q1).string ())
+  write ("Product of " || q.string() || " and " || r || " is " || q.multiply(r).string ())
+  write ("Product of " || q.string() || " and " || q1.string() || " is " || q.multiply(q1).string ())
+  write ("q1*q2 = " || q1.multiply(q2).string ())
+  write ("q2*q1 = " || q2.multiply(q1).string ())
 end