resize => sized

micro/reduce-segmented.fut

@@ -29,7 +29,7 @@ entry sum_iota_i32 n m: []i32 = array i32.i64 n m |> map i32.sum
 -- only_c random input { 10000000 10 [100000000]i8 }
 -- only_c random input { 100000000 1 [100000000]i8 }
 
-entry sum_i8 n m xs: []i8 = unflatten (resize (i64.i32 n*i64.i32 m) xs) |> map i8.sum
+entry sum_i8 n m xs: []i8 = unflatten (sized (i64.i32 n*i64.i32 m) xs) |> map i8.sum
 
 -- ==
 -- entry: sum_i16
@@ -43,7 +43,7 @@ entry sum_i8 n m xs: []i8 = unflatten (resize (i64.i32 n*i64.i32 m) xs) |> map i
 -- only_c random input { 10000000 10 [100000000]i16 }
 -- only_c random input { 100000000 1 [100000000]i16 }
 
-entry sum_i16 n m xs: []i16 = unflatten (resize (i64.i32 n*i64.i32 m) xs) |> map i16.sum
+entry sum_i16 n m xs: []i16 = unflatten (sized (i64.i32 n*i64.i32 m) xs) |> map i16.sum
 
 -- ==
 -- entry: sum_i32
@@ -57,7 +57,7 @@ entry sum_i16 n m xs: []i16 = unflatten (resize (i64.i32 n*i64.i32 m) xs) |> map
 -- only_c random input { 10000000 10 [100000000]i32 }
 -- only_c random input { 100000000 1 [100000000]i32 }
 
-entry sum_i32 n m xs: []i32 = unflatten (resize (i64.i32 n*i64.i32 m) xs) |> map i32.sum
+entry sum_i32 n m xs: []i32 = unflatten (sized (i64.i32 n*i64.i32 m) xs) |> map i32.sum
 
 -- ==
 -- entry: sum_i64
@@ -71,7 +71,7 @@ entry sum_i32 n m xs: []i32 = unflatten (resize (i64.i32 n*i64.i32 m) xs) |> map
 -- only_c random input { 10000000 10 [100000000]i64 }
 -- only_c random input { 100000000 1 [100000000]i64 }
 
-entry sum_i64 n m xs: []i64 = unflatten (resize (i64.i32 n*i64.i32 m) xs) |> map i64.sum
+entry sum_i64 n m xs: []i64 = unflatten (sized (i64.i32 n*i64.i32 m) xs) |> map i64.sum
 
 -- Now for some non-commutative reductions.
 
@@ -95,9 +95,9 @@ def mat4_mul (+) (*) (a0,a1,a2,a3) (b0,b1,b2,b3) =
 def mat4' f a b c d = (f a, f b, f c, f d)
 
 entry prod_mat4_i32 n m as bs cs ds =
-  let ass = unflatten (resize (i64.i32 n*i64.i32 m) as)
-  let bss = unflatten (resize (i64.i32 n*i64.i32 m) bs)
-  let css = unflatten (resize (i64.i32 n*i64.i32 m) cs)
-  let dss = unflatten (resize (i64.i32 n*i64.i32 m) ds)
+  let ass = unflatten (sized (i64.i32 n*i64.i32 m) as)
+  let bss = unflatten (sized (i64.i32 n*i64.i32 m) bs)
+  let css = unflatten (sized (i64.i32 n*i64.i32 m) cs)
+  let dss = unflatten (sized (i64.i32 n*i64.i32 m) ds)
   in map4 (map4 (mat4' id)) ass bss css dss
      |> map (reduce (mat4_mul (i32.+) (i32.*)) (1, 0, 0, 1) >-> (.0))

micro/reduce_by_index.fut

@@ -67,7 +67,7 @@ entry absmax_i32 [n] (k: i32) (is : [n]i32) (vs : [n]i32) : []i32 =
 
 entry sum_vec_i32 [n][m] (k: i32) (is : [m]i32) (vs : [n]i32) : [][]i32 =
   let l = n/m
-  let vs' = unflatten (resize (m*l) vs)
+  let vs' = unflatten (sized (m*l) vs)
   in hist (map2 (+)) (replicate l 0) (i64.i32 k) (bins k is) vs'
 
 -- An operator that the compiler really cannot do anything clever

micro/transpose.fut

@@ -46,7 +46,7 @@
 -- only_c random input { 50000000  2 [100000000]i64 }
 -- only_c random input { 100000000 1 [100000000]i64 }
 
-def unpack_2d n m = resize (i64.i32 n*i64.i32 m) >-> unflatten
+def unpack_2d n m = sized (i64.i32 n*i64.i32 m) >-> unflatten
 
 entry transpose_i8  n m xs: [][]i8  = unpack_2d n m xs |> transpose
 entry transpose_i32 n m xs: [][]i32 = unpack_2d n m xs |> transpose
@@ -88,7 +88,7 @@ entry transpose_i64 n m xs: [][]i64 = unpack_2d n m xs |> transpose
 -- only_c random input { 10 10000000 1 [100000000]i64 }
 -- only_c random input { 1000 100000 1 [100000000]i64 }
 
-def unpack_3d k n m = resize (i64.i32 k*i64.i32 n*i64.i32 m) >-> unflatten_3d
+def unpack_3d k n m = sized (i64.i32 k*i64.i32 n*i64.i32 m) >-> unflatten_3d
 
 entry map_transpose_i8  k n m xs:  [][][]i8 = unpack_3d k n m xs |> map transpose
 entry map_transpose_i32 k n m xs: [][][]i32 = unpack_3d k n m xs |> map transpose

misc/knn-by-kdtree/buildKDtree.fut

@@ -105,7 +105,7 @@ def mkKDtree [m] [d] (height: i32) (q: i64) (m' : i64)
              for lev < (height+1) do
                let nodes_this_lvl = 1 << i64.i32 lev
                let pts_per_node_at_lev = m' / nodes_this_lvl
-               let indir2d = unflatten (resize (nodes_this_lvl*pts_per_node_at_lev) indir)
+               let indir2d = unflatten (sized (nodes_this_lvl*pts_per_node_at_lev) indir)
 
                -- compute the dimensions to be split for each node at this level
                -- and also the index of the closest ancestor that has split the
@@ -154,7 +154,7 @@ def mkKDtree [m] [d] (height: i32) (q: i64) (m' : i64)
                let median_dims' = scatter median_dims this_lev_inds med_dims
                let median_vals' = scatter median_vals this_lev_inds med_vals
                let clanc_eqdim' = scatter clanc_eqdim this_lev_inds anc_same_med
-               let indir'' = resize m' (flatten indir2d')
+               let indir'' = sized m' (flatten indir2d')
 
                in  (indir'', median_dims', median_vals', clanc_eqdim')
 

misc/knn-by-kdtree/driver-knn.fut

@@ -13,7 +13,7 @@ def propagate [m][q][d][n] (ref_pts: [m][d]f32) (indir: [m]i32)
   let num_leaves = num_nodes + 1
   let h = (log2 (i32.i64 num_leaves)) - 1
   let ppl = m / num_leaves
-  let leaves = unflatten (resize (num_leaves*ppl) ref_pts)
+  let leaves = unflatten (sized (num_leaves*ppl) ref_pts)
 
   let query_leaves = map (findLeaf median_dims median_vals h) queries
   let (query_leaves, query_inds) = sortQueriesByLeavesRadix (h+1) query_leaves

misc/knn-by-kdtree/knn-iteration.fut

@@ -44,7 +44,8 @@ def iterationSorted [q][n][d][k][N][num_leaves][ppl]
   let ongoing_queries'= (gather2D ongoing_queries sort_inds)[:num_valid]
   let query_inds_all  = gather1D query_inds sort_inds
   let knns_all        = gather2D knns' sort_inds
-  let (valid, terminated) = split (resize (num_valid+(n-num_valid)) (zip query_inds_all knns_all))
+  let (valid, terminated) = (take num_valid (zip query_inds_all knns_all),
+                             drop num_valid (zip query_inds_all knns_all))
   let (query_inds', knns'')= unzip valid
   let (terminated_inds, terminated_knns) = unzip terminated
   let ord_knns' = scatter2D ord_knns terminated_inds terminated_knns

misc/poseidon/poseidon.fut

@@ -48,7 +48,7 @@ def div_evenly (a: i32) (b: i32): i32 = assert (a % b == 0) a /b
 
 def even_chunks 't [n]  (chunk_size: i64) (arr: [n] t) =
   let chunk_count = div_evenly64 n chunk_size
-  in unflatten (resize (chunk_count*chunk_size) arr)
+  in unflatten (sized (chunk_count*chunk_size) arr)
 
 
 module type hasher  = {

parboil/tpacf/tpacf.fut

@@ -110,4 +110,4 @@ def main [numD][numRs]
   let dd = doComputeSelf datapoints numBins2 binb
   let rr = sumBins rrs
   let dr = sumBins drs
-  in [dd, dr, rr] |> transpose |> init |> tail |> flatten |> resize 60
+  in [dd, dr, rr] |> transpose |> init |> tail |> flatten |> sized 60