Records changed.

Author: athas

src/lines.fut

@@ -36,11 +36,11 @@ let linepoints (p1:point) (p2:point) : points =
     let len = i32.max (i32.abs(x1-x2)) (i32.abs(y1-y2))
     let dirx = if x2 > x1 then 1 else if x1 > x2 then -1 else 0
     let slop = if x2==x1 then
-                  if y2 > y1 then f32(1) else f32(-1)
-	       else f32(y2-y1) / f32.abs(f32(x2-x1))
+                  if y2 > y1 then 1f32 else -1f32
+	       else r32(y2-y1) / f32.abs(r32(x2-x1))
     in map (\i ->
               let x = x1+i*dirx
-	      let y = y1+i32(slop*f32(i))
+	      let y = y1+t32(slop*r32(i))
 	      in (x,y))
        (iota(len))
 
@@ -49,8 +49,8 @@ let drawlines_seq [h][w][n] (grid: *[h][w]i32) (lines:[n]line) : [h][w]i32 =
     let (p1,p2) = lines[i]
     let ps = linepoints p1 p2
     in loop (grid) for j < length ps do
-         let x = #1 (ps[j])
-         let y = #2 (ps[j])
+         let x = (ps[j]).1
+         let y = (ps[j]).2
          let grid[y,x] = 1
          in grid
 
@@ -79,13 +79,13 @@ let drawlines_par [h][w][n] (grid:*[h][w]i32) (lines:[n]line) :[h][w]i32 =
 		        else 0) xs1 xs2
   let slops = map (\x1 y1 x2 y2 ->
                         if x2 == x1 then
-   	   	        if y2 > y1 then f32(1) else f32(-1)
-		        else f32(y2-y1) / f32.abs(f32(x2-x1))) xs1 ys1 xs2 ys2
+   	   	        if y2 > y1 then 1f32 else -1f32
+		        else r32(y2-y1) / f32.abs(r32(x2-x1))) xs1 ys1 xs2 ys2
   let iotas = sgmIota flags
   let xs = map (\x1 dirx i ->
                      x1+dirx*i) xs1 dirxs iotas
   let ys = map (\y1 slop i ->
-                     y1+i32(slop*f32(i))) ys1 slops iotas
+                     y1+t32(slop*r32(i))) ys1 slops iotas
   let is = map (\x y -> w*y+x) xs ys
   let flatgrid = reshape (h*w) grid
   in reshape (h,w) (scatter flatgrid is (replicate nn 1))

src/lines_flat.fut

@@ -53,13 +53,13 @@ let drawlines [h][w][n] (grid:*[h][w]i32) (lines:[n]line) :[h][w]i32 =
                      else 0) lines1
   let slops = map (\((x1,y1),(x2,y2)) ->
                      if x2 == x1 then
-                       if y2 > y1 then f32(1) else f32(-1)
-                     else f32(y2-y1) / f32.abs(f32(x2-x1))) lines1
+                       if y2 > y1 then 1f32 else -1f32
+                     else r32(y2-y1) / f32.abs(r32(x2-x1))) lines1
   let iotas = sgm_iota flags
   let xs = map (\((x1,_),_) dirx i ->
                   x1+dirx*i) lines1 dirxs iotas
   let ys = map (\((_,y1),_) slop i ->
-                  y1+i32(slop*f32(i))) lines1 slops iotas
+                  y1+t32(slop*r32(i))) lines1 slops iotas
   in upd_grid grid xs ys
 
 let main () : [][]i32 =

src/lines_seq.fut

@@ -12,17 +12,17 @@ let compare (v1:i32) (v2:i32) : i32 =
   if v2 > v1 then 1 else if v1 > v2 then -1 else 0
 
 let slo ((x1,y1):point) ((x2,y2):point) : f32 =
-  if x2==x1 then if y2>y1 then f32(1) else f32(-1)
-                 else f32(y2-y1) / f32.abs(f32(x2-x1))
+  if x2==x1 then if y2>y1 then 1f32 else -1f32
+                 else r32(y2-y1) / f32.abs(r32(x2-x1))
 
 let linepoints ((x1,y1):point, (x2,y2):point) : points =
   let len = 1 + i32.max (i32.abs(x2-x1)) (i32.abs(y2-y1))
   let xmax = i32.abs(x2-x1) > i32.abs(y2-y1)
   let (dir,slop) =
     if xmax then (compare x1 x2, slo (x1,y1) (x2,y2))
     else (compare y1 y2, slo (y1,x1) (y2,x2))
-  in map (\i -> if xmax then (x1+i*dir, y1+i32(slop*f32(i)))
-                else (x1+i32(slop*f32(i)), y1+i*dir)) (iota len)
+  in map (\i -> if xmax then (x1+i*dir, y1+t32(slop*r32(i)))
+                else (x1+t32(slop*r32(i)), y1+i*dir)) (iota len)
 
 -- Write to grid
 let update [h] [w] [n] (grid:*[h][w]i32)(xs:[n]i32)(ys:[n]i32):*[h][w]i32 =

src/lines_seq2.fut

@@ -12,8 +12,8 @@ let compare (v1:i32) (v2:i32) : i32 =
 
 -- Compute a slope
 let sl ((x1,y1):point) ((x2,y2):point) : f32 =
-  if x2==x1 then if y2>y1 then f32(1) else f32(-1)
-		 else f32(y2-y1) / f32.abs(f32(x2-x1))
+  if x2==x1 then if y2>y1 then 1f32 else -1f32
+		 else r32(y2-y1) / f32.abs(r32(x2-x1))
 
 let linepoints ((x1,y1):point, (x2,y2):point) : points =
   let dx = i32.abs(x1-x2)
@@ -27,8 +27,8 @@ let linepoints ((x1,y1):point, (x2,y2):point) : points =
     else sl (y1,x1) (y2,x2)
   in map (\i ->
             if xmax then (x1+i*dir,
-			  y1+i32(slop*f32(i)))
-	    else (x1+i32(slop*f32(i)),
+			  y1+t32(slop*r32(i)))
+	    else (x1+t32(slop*r32(i)),
 		  y1+i*dir))
          (iota len)
 

src/radix_sort.fut

@@ -16,8 +16,8 @@ module Array = import "/futlib/array"
 -- A least significant digit radix sort to test out `write`.
 let radix_sort_step [n] (xs: [n]u32, digit_n: i32): [n]u32 =
   let bits       = map (\(x: u32): i32 ->
-                          i32((x >> u32(digit_n))
-                              & 1u32)) xs
+                          (i32.u32 x >> digit_n)
+                          & 1) xs
   let bits_inv   = map (\(b: i32): i32 -> 1 - b) bits
   let ps0        = scan (+) 0 (bits_inv)
   let ps0_clean  = map (*) bits_inv ps0
@@ -34,5 +34,5 @@ let radix_sort [n] (xs: [n]u32): [n]u32 =
     radix_sort_step(xs, i)
 
 let main(): []u32 =
-  let arg = map u32 ([83, 1, 4, 99, 33, 0, 6, 5])
+  let arg = map u32.i32 ([83, 1, 4, 99, 33, 0, 6, 5])
   in radix_sort(arg)

src/rsort.fut

@@ -17,7 +17,7 @@ module Array = import "/futlib/array"
 -- all elements with bitn set to the end of the array (and
 -- otherwise preserve the order of elements)
 let rsort_step [n] (xs: [n]u32, bitn: i32): [n]u32 =
-  let bits1 = map (\x -> i32((x >> u32(bitn)) & 1u32)) xs
+  let bits1 = map (\x -> (i32.u32 x >>> bitn) & 1) xs
   let bits0 = map (1-) bits1
   let idxs0 = map (*) bits0 (scan (+) 0 bits0)
   let idxs1 = scan (+) 0 bits1

src/rsort_idx.fut

@@ -13,7 +13,7 @@ module Array = import "/futlib/array"
 
 -- Store elements for which bitn is not set first
 let rs_step_asc [n] ((xs:[n]u32,is:[n]i32),bitn:i32) : ([n]u32,[n]i32) =
-  let bits1 = map (\x -> i32((x >> u32(bitn)) & 1u32)) xs
+  let bits1 = map (\x -> (i32.u32 x >>> bitn) & 1) xs
   let bits0 = map (1-) bits1
   let idxs0 = map (*) bits0 (scan (+) 0 bits0)
   let idxs1 = scan (+) 0 bits1
@@ -32,7 +32,7 @@ let rsort_asc [n] (xs: [n]u32) : ([n]u32,[n]i32) =
 
 -- Store elements for which bitn is set first
 let rs_step_desc [n] ((xs:[n]u32,is:[n]i32),bitn:i32) : ([n]u32,[n]i32) =
-  let bits1 = map (\x -> i32((x >> u32(bitn)) & 1u32)) xs
+  let bits1 = map (\x -> (i32.u32 x >>> bitn) & 1) xs
   let bits0 = map (1-) bits1
   let idxs1 = map (*) bits1 (scan (+) 0 bits1)
   let idxs0 = scan (+) 0 bits0
@@ -58,6 +58,6 @@ let eq_vec [n] (v1: [n]i32) (v2: [n]i32) : bool =
   reduce (&&) true (map (==) v1 v2)
 
 let main() : []bool =
-  let xs = map (\i -> u32(i)) ([83,1,4,99,33,0,6,5])
+  let xs = map u32.i32 ([83,1,4,99,33,0,6,5])
   in [eq_vec (grade_up xs) ([5,1,2,7,6,4,0,3]),
       eq_vec (grade_down xs) ([3,0,4,6,7,2,1,5])]