| 1 |
- BlackBox: |
| 2 |
name: Clash.Sized.Vector.head |
| 3 |
kind: Expression |
| 4 |
type: 'head :: Vec (n + 1) a -> a' |
| 5 |
template: '~FROMBV[~VAR[vec][0][\~SIZE[~TYP[0]]-1 -: ~SIZE[~TYPO]\]][~TYPO]' |
| 6 |
workInfo: Never |
| 7 |
- BlackBox: |
| 8 |
name: Clash.Sized.Vector.tail |
| 9 |
kind: Expression |
| 10 |
type: 'tail :: Vec (n + 1) a -> Vec n a' |
| 11 |
template: '~VAR[vec][0][~SIZE[~TYPO]-1 : 0]' |
| 12 |
workInfo: Never |
| 13 |
- BlackBox: |
| 14 |
name: Clash.Sized.Vector.last |
| 15 |
kind: Expression |
| 16 |
type: Vec (n + 1) a -> a |
| 17 |
template: ~FROMBV[~VAR[vec][0][\~SIZE[~TYPO]-1:0\]][~TYPO] |
| 18 |
workInfo: Never |
| 19 |
- BlackBox: |
| 20 |
name: Clash.Sized.Vector.init |
| 21 |
kind: Expression |
| 22 |
type: Vec (n + 1) a -> Vec n a |
| 23 |
template: '~VAR[vec][0][~SIZE[~TYP[0]]-1 : ~SIZE[~TYPEL[~TYP[0]]]]' |
| 24 |
workInfo: Never |
| 25 |
- BlackBox: |
| 26 |
name: Clash.Sized.Vector.select |
| 27 |
kind: Declaration |
| 28 |
type: |- |
| 29 |
select :: (CmpNat (i + s) (s * n) ~ GT) -- ARG[0] |
| 30 |
=> SNat f -- ARG[1] |
| 31 |
-> SNat s -- ARG[2] |
| 32 |
-> SNat n -- ARG[3] |
| 33 |
-> Vec i a -- ARG[4] |
| 34 |
-> Vec n a |
| 35 |
template: |- |
| 36 |
// select begin |
| 37 |
wire ~TYPEL[~TYPO] ~SYM[1] [0:~LENGTH[~TYP[4]]-1]; |
| 38 |
genvar ~GENSYM[i][2]; |
| 39 |
~GENERATE |
| 40 |
for (~SYM[2]=0; ~SYM[2] < ~LENGTH[~TYP[4]]; ~SYM[2]=~SYM[2]+1) begin : ~GENSYM[mk_array][3] |
| 41 |
assign ~SYM[1][(~LENGTH[~TYP[4]]-1)-~SYM[2]] = ~VAR[vec][4][~SYM[2]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]]; |
| 42 |
end |
| 43 |
~ENDGENERATE |
| 44 |
|
| 45 |
genvar ~GENSYM[i][4]; |
| 46 |
~GENERATE |
| 47 |
for (~SYM[4]=0; ~SYM[4] < ~LIT[3]; ~SYM[4] = ~SYM[4] + 1) begin : ~GENSYM[select][5] |
| 48 |
assign ~RESULT[(~LIT[3]-1-~SYM[4])*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[1][~LIT[1] + (~LIT[2] * ~SYM[4])]; |
| 49 |
end |
| 50 |
~ENDGENERATE |
| 51 |
// select end |
| 52 |
workInfo: Never |
| 53 |
- BlackBox: |
| 54 |
name: Clash.Sized.Vector.++ |
| 55 |
kind: Expression |
| 56 |
type: '(++) :: Vec n a -> Vec m a -> Vec (n + m) a' |
| 57 |
template: '{~ARG[0],~ARG[1]}' |
| 58 |
workInfo: Never |
| 59 |
- BlackBox: |
| 60 |
name: Clash.Sized.Vector.concat |
| 61 |
kind: Expression |
| 62 |
type: 'concat :: Vec n (Vec m a) -> Vec (n * m) a' |
| 63 |
template: ~ARG[0] |
| 64 |
workInfo: Never |
| 65 |
- BlackBox: |
| 66 |
name: Clash.Sized.Vector.splitAt |
| 67 |
kind: Expression |
| 68 |
type: 'splitAt :: SNat m -> Vec (m + n) a -> (Vec m a, Vec n a)' |
| 69 |
template: ~ARG[1] |
| 70 |
workInfo: Never |
| 71 |
- BlackBox: |
| 72 |
name: Clash.Sized.Vector.unconcat |
| 73 |
kind: Expression |
| 74 |
type: |- |
| 75 |
unconcat :: KnownNat n -- ARG[0] |
| 76 |
=> SNat m -- ARG[1] |
| 77 |
-> Vec (n * m) a -- ARG[2] |
| 78 |
-> Vec n (Vec m a) |
| 79 |
template: ~ARG[2]~DEVNULL[~ARG[0]]~DEVNULL[~ARG[1]] |
| 80 |
workInfo: Never |
| 81 |
- BlackBox: |
| 82 |
name: Clash.Sized.Vector.map |
| 83 |
kind: Declaration |
| 84 |
type: 'map :: (a -> b) -> Vec n a -> Vec n b' |
| 85 |
template: |- |
| 86 |
// map begin |
| 87 |
genvar ~GENSYM[i][1]; |
| 88 |
~GENERATE |
| 89 |
for (~SYM[1]=0; ~SYM[1] < ~LENGTH[~TYPO]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[map][2]~IF~SIZE[~TYP[1]]~THEN |
| 90 |
wire ~TYPEL[~TYP[1]] ~GENSYM[map_in][3]; |
| 91 |
assign ~SYM[3] = ~VAR[vec][1][~SYM[1]*~SIZE[~TYPEL[~TYP[1]]]+:~SIZE[~TYPEL[~TYP[1]]]];~ELSE ~FI |
| 92 |
~OUTPUTUSAGE[0] ~TYPEL[~TYPO] ~GENSYM[map_out][4]; |
| 93 |
~INST 0 |
| 94 |
~OUTPUT <= ~SYM[4]~ ~TYPEL[~TYPO]~ |
| 95 |
~INPUT <= ~SYM[3]~ ~TYPEL[~TYP[1]]~ |
| 96 |
~INST |
| 97 |
assign ~RESULT[~SYM[1]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[4]; |
| 98 |
end |
| 99 |
~ENDGENERATE |
| 100 |
// map end |
| 101 |
workInfo: Identity 1 [0] |
| 102 |
- BlackBox: |
| 103 |
name: Clash.Sized.Vector.imap |
| 104 |
kind: Declaration |
| 105 |
type: 'imap :: KnownNat n => (Index n -> a -> b) -> Vec n a -> Vec n b' |
| 106 |
template: |- |
| 107 |
// imap begin |
| 108 |
genvar ~GENSYM[i][1]; |
| 109 |
~GENERATE |
| 110 |
for (~SYM[1]=0; ~SYM[1] < ~LENGTH[~TYPO]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[imap][2] |
| 111 |
wire [~SIZE[~INDEXTYPE[~LIT[0]]]-1:0] ~GENSYM[map_index][3];~IF~SIZE[~TYP[2]]~THEN |
| 112 |
wire ~TYPEL[~TYP[2]] ~GENSYM[map_in][4]; |
| 113 |
assign ~SYM[4] = ~VAR[vec][2][~SYM[1]*~SIZE[~TYPEL[~TYP[2]]]+:~SIZE[~TYPEL[~TYP[2]]]];~ELSE ~FI |
| 114 |
~OUTPUTUSAGE[1] ~TYPEL[~TYPO] ~GENSYM[map_out][5]; |
| 115 |
|
| 116 |
assign ~SYM[3] = ~SIZE[~INDEXTYPE[~LIT[0]]]'d~MAXINDEX[~TYPO] - ~SYM[1][0+:~SIZE[~INDEXTYPE[~LIT[0]]]]; |
| 117 |
~INST 1 |
| 118 |
~OUTPUT <= ~SYM[5]~ ~TYPEL[~TYPO]~ |
| 119 |
~INPUT <= ~SYM[3]~ ~INDEXTYPE[~LIT[0]]~ |
| 120 |
~INPUT <= ~SYM[4]~ ~TYPEL[~TYP[2]]~ |
| 121 |
~INST |
| 122 |
assign ~RESULT[~SYM[1]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[5]; |
| 123 |
end |
| 124 |
~ENDGENERATE |
| 125 |
// imap end |
| 126 |
workInfo: Never |
| 127 |
- BlackBox: |
| 128 |
name: Clash.Sized.Vector.imap_go |
| 129 |
kind: Declaration |
| 130 |
type: 'imap_go :: (Index n -> a -> b) -> Vec m a -> Index n -> Vec m b' |
| 131 |
template: |- |
| 132 |
// imap begin |
| 133 |
genvar ~GENSYM[i][1]; |
| 134 |
~GENERATE |
| 135 |
for (~SYM[1]=0; ~SYM[1] < ~LENGTH[~TYPO]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[imap][2] |
| 136 |
wire ~TYP[2] ~GENSYM[map_index][3];~IF~SIZE[~TYP[1]]~THEN |
| 137 |
wire ~TYPEL[~TYP[1]] ~GENSYM[map_in][4]; |
| 138 |
assign ~SYM[4] = ~VAR[vec][1][~SYM[1]*~SIZE[~TYPEL[~TYP[1]]]+:~SIZE[~TYPEL[~TYP[1]]]];~ELSE ~FI |
| 139 |
~OUTPUTUSAGE[0] ~TYPEL[~TYPO] ~GENSYM[map_out][5]; |
| 140 |
|
| 141 |
assign ~SYM[3] = ~SIZE[~TYP[2]]'d~MAXINDEX[~TYPO] - ~SYM[1][0+:~SIZE[~TYP[2]]] + ~ARG[2]; |
| 142 |
~INST 0 |
| 143 |
~OUTPUT <= ~SYM[5]~ ~TYPEL[~TYPO]~ |
| 144 |
~INPUT <= ~SYM[3]~ ~TYP[2]~ |
| 145 |
~INPUT <= ~SYM[4]~ ~TYPEL[~TYP[1]]~ |
| 146 |
~INST |
| 147 |
assign ~RESULT[~SYM[1]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[5]; |
| 148 |
end |
| 149 |
~ENDGENERATE |
| 150 |
// imap end |
| 151 |
workInfo: Never |
| 152 |
- BlackBox: |
| 153 |
name: Clash.Sized.Vector.zipWith |
| 154 |
kind: Declaration |
| 155 |
type: 'zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c' |
| 156 |
template: |- |
| 157 |
// zipWith start |
| 158 |
genvar ~GENSYM[i][2]; |
| 159 |
~GENERATE |
| 160 |
for (~SYM[2] = 0; ~SYM[2] < ~LENGTH[~TYPO]; ~SYM[2] = ~SYM[2] + 1) begin : ~GENSYM[zipWith][6]~IF~SIZE[~TYP[1]]~THEN |
| 161 |
wire ~TYPEL[~TYP[1]] ~GENSYM[zipWith_in1][3]; |
| 162 |
assign ~SYM[3] = ~VAR[vec1][1][~SYM[2]*~SIZE[~TYPEL[~TYP[1]]]+:~SIZE[~TYPEL[~TYP[1]]]];~ELSE ~FI~IF~SIZE[~TYP[2]]~THEN |
| 163 |
wire ~TYPEL[~TYP[2]] ~GENSYM[zipWith_in2][4]; |
| 164 |
assign ~SYM[4] = ~VAR[vec2][2][~SYM[2]*~SIZE[~TYPEL[~TYP[2]]]+:~SIZE[~TYPEL[~TYP[2]]]];~ELSE ~FI |
| 165 |
~OUTPUTUSAGE[0] ~TYPEL[~TYPO] ~SYM[5]; |
| 166 |
~INST 0 |
| 167 |
~OUTPUT <= ~SYM[5]~ ~TYPEL[~TYPO]~ |
| 168 |
~INPUT <= ~SYM[3]~ ~TYPEL[~TYP[1]]~ |
| 169 |
~INPUT <= ~SYM[4]~ ~TYPEL[~TYP[2]]~ |
| 170 |
~INST |
| 171 |
assign ~RESULT[~SYM[2]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[5]; |
| 172 |
end |
| 173 |
~ENDGENERATE |
| 174 |
// zipWith end |
| 175 |
workInfo: Never |
| 176 |
- BlackBox: |
| 177 |
name: Clash.Sized.Vector.foldr |
| 178 |
kind: Declaration |
| 179 |
type: 'foldr :: (a -> b -> b) -> b -> Vec n a -> b' |
| 180 |
template: |- |
| 181 |
// foldr start~IF ~LENGTH[~TYP[2]] ~THEN |
| 182 |
wire ~TYPO ~GENSYM[intermediate][0] [0:~LENGTH[~TYP[2]]]; |
| 183 |
assign ~SYM[0][~LENGTH[~TYP[2]]] = ~ARG[1]; |
| 184 |
|
| 185 |
genvar ~GENSYM[i][3]; |
| 186 |
~GENERATE |
| 187 |
for (~SYM[3]=0; ~SYM[3] < ~LENGTH[~TYP[2]]; ~SYM[3]=~SYM[3]+1) begin : ~GENSYM[foldr][4]~IF~SIZE[~TYP[2]]~THEN |
| 188 |
wire ~TYPEL[~TYP[2]] ~GENSYM[foldr_in1][5]; |
| 189 |
assign ~SYM[5] = ~VAR[xs][2][(~LENGTH[~TYP[2]]-1-~SYM[3])*~SIZE[~TYPEL[~TYP[2]]]+:~SIZE[~TYPEL[~TYP[2]]]];~ELSE ~FI |
| 190 |
wire ~TYPO ~GENSYM[foldr_in2][6]; |
| 191 |
~OUTPUTUSAGE[0] ~TYPO ~GENSYM[foldr_out][7]; |
| 192 |
|
| 193 |
assign ~SYM[6] = ~SYM[0][~SYM[3]+1]; |
| 194 |
~INST 0 |
| 195 |
~OUTPUT <= ~SYM[7]~ ~TYP[1]~ |
| 196 |
~INPUT <= ~SYM[5]~ ~TYPEL[~TYP[2]]~ |
| 197 |
~INPUT <= ~SYM[6]~ ~TYP[1]~ |
| 198 |
~INST |
| 199 |
assign ~SYM[0][~SYM[3]] = ~SYM[7]; |
| 200 |
end |
| 201 |
~ENDGENERATE |
| 202 |
|
| 203 |
assign ~RESULT = ~SYM[0][0]; |
| 204 |
~ELSE |
| 205 |
assign ~RESULT = ~ARG[1]; |
| 206 |
~FI// foldr end |
| 207 |
workInfo: Never |
| 208 |
- BlackBoxHaskell: |
| 209 |
name: Clash.Sized.Vector.index_int |
| 210 |
templateFunction: Clash.Primitives.Sized.Vector.indexIntVerilog |
| 211 |
- BlackBox: |
| 212 |
name: Clash.Sized.Vector.replace_int |
| 213 |
kind: Declaration |
| 214 |
type: 'replace_int :: KnownNat n => Vec n a -> Int -> a -> Vec n a' |
| 215 |
template: |- |
| 216 |
// vector replace begin |
| 217 |
genvar ~GENSYM[i][0]; |
| 218 |
~GENERATE |
| 219 |
for (~SYM[0]=0;~SYM[0]<~LENGTH[~TYPO];~SYM[0]=~SYM[0]+1) begin : ~GENSYM[vector_replace][1] |
| 220 |
assign ~RESULT[(~MAXINDEX[~TYPO]-~SYM[0])*~SIZE[~TYP[3]]+:~SIZE[~TYP[3]]] = ~ARG[2] == ~SYM[0] ? ~ARG[3] : ~VAR[vec][1][(~MAXINDEX[~TYPO]-~SYM[0])*~SIZE[~TYP[3]]+:~SIZE[~TYP[3]]]; |
| 221 |
end |
| 222 |
~ENDGENERATE |
| 223 |
// vector replace end |
| 224 |
- BlackBox: |
| 225 |
name: Clash.Sized.Vector.maxIndex |
| 226 |
kind: Expression |
| 227 |
type: 'maxIndex :: KnownNat n => Vec n a -> Int' |
| 228 |
template: ~SIZE[~TYPO]'sd~LIT[0] - ~SIZE[~TYPO]'d1 |
| 229 |
workInfo: Constant |
| 230 |
- BlackBox: |
| 231 |
name: Clash.Sized.Vector.length |
| 232 |
kind: Expression |
| 233 |
type: 'length :: KnownNat n => Vec n a -> Int' |
| 234 |
template: ~SIZE[~TYPO]'sd~LIT[0] |
| 235 |
workInfo: Constant |
| 236 |
- BlackBox: |
| 237 |
name: Clash.Sized.Vector.replicate |
| 238 |
kind: Expression |
| 239 |
type: 'replicate :: SNat n -> a -> Vec n a' |
| 240 |
template: '{~LIT[0] {~ARG[1]}}' |
| 241 |
workInfo: Never |
| 242 |
- BlackBox: |
| 243 |
name: Clash.Sized.Vector.transpose |
| 244 |
kind: Declaration |
| 245 |
type: 'transpose :: KnownNat n => Vec m (Vec n a) -> Vec n (Vec m a)' |
| 246 |
template: |- |
| 247 |
// transpose begin |
| 248 |
genvar ~GENSYM[row_index][1]; |
| 249 |
genvar ~GENSYM[col_index][2]; |
| 250 |
~GENERATE |
| 251 |
for (~SYM[1] = 0; ~SYM[1] < ~LENGTH[~TYP[1]]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[transpose_outer][3] |
| 252 |
for (~SYM[2] = 0; ~SYM[2] < ~LENGTH[~TYPO]; ~SYM[2] = ~SYM[2] + 1) begin : ~GENSYM[transpose_inner][4] |
| 253 |
assign ~RESULT[((~SYM[2]*~SIZE[~TYPEL[~TYPO]])+(~SYM[1]*~SIZE[~TYPEL[~TYPEL[~TYPO]]]))+:~SIZE[~TYPEL[~TYPEL[~TYPO]]]] = ~VAR[matrix][1][((~SYM[1]*~SIZE[~TYPEL[~TYP[1]]])+(~SYM[2]*~SIZE[~TYPEL[~TYPEL[~TYPO]]]))+:~SIZE[~TYPEL[~TYPEL[~TYPO]]]]; |
| 254 |
end |
| 255 |
end |
| 256 |
~ENDGENERATE |
| 257 |
// transpose end |
| 258 |
workInfo: Never |
| 259 |
- BlackBox: |
| 260 |
name: Clash.Sized.Vector.reverse |
| 261 |
kind: Declaration |
| 262 |
type: 'reverse :: Vec n a -> Vec n a' |
| 263 |
template: |- |
| 264 |
// reverse begin |
| 265 |
genvar ~GENSYM[i][1]; |
| 266 |
~GENERATE |
| 267 |
for (~SYM[1] = 0; ~SYM[1] < ~LENGTH[~TYPO]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[reverse][2] |
| 268 |
assign ~RESULT[(~LENGTH[~TYPO] - 1 - ~SYM[1])*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~VAR[vec][0][~SYM[1]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]]; |
| 269 |
end |
| 270 |
~ENDGENERATE |
| 271 |
// reverse end |
| 272 |
workInfo: Never |
| 273 |
- BlackBox: |
| 274 |
name: Clash.Sized.Vector.concatBitVector# |
| 275 |
kind: Expression |
| 276 |
type: |- |
| 277 |
concatBitVector# :: (KnownNat n, KnownNat m) -- (ARG[0],ARG[1]) |
| 278 |
=> Vec n (BitVector m) -- ARG[2] |
| 279 |
-> BitVector (n * m) |
| 280 |
template: ~ARG[2] |
| 281 |
workInfo: Never |
| 282 |
- BlackBox: |
| 283 |
name: Clash.Sized.Vector.unconcatBitVector# |
| 284 |
kind: Expression |
| 285 |
type: |- |
| 286 |
unconcatBitVector# :: (KnownNat n, KnownNat m) -- (ARG[0],ARG[1]) |
| 287 |
=> BitVector (n * m) -- ARG[2] |
| 288 |
-> Vec n (BitVector m) |
| 289 |
template: ~ARG[2] |
| 290 |
workInfo: Never |
| 291 |
- BlackBox: |
| 292 |
name: Clash.Sized.Vector.rotateLeftS |
| 293 |
kind: Declaration |
| 294 |
type: 'rotateLeftS :: KnownNat n => Vec n a -> SNat d -> Vec n a' |
| 295 |
template: |- |
| 296 |
// rotateLeftS begin |
| 297 |
localparam ~GENSYM[shift_amount][2] = ~LIT[2] % ~LIT[0]; |
| 298 |
|
| 299 |
~GENERATE |
| 300 |
if (~SYM[2] == 0) begin : ~GENSYM[no_shift][3] |
| 301 |
assign ~RESULT = ~VAR[vec][1]; |
| 302 |
end else begin : ~GENSYM[do_shift][4] |
| 303 |
assign ~RESULT = {~VAR[vec][1][((~LIT[0]-~SYM[2])*~SIZE[~TYPEL[~TYPO]])-1 : 0] |
| 304 |
,~VAR[vec][1][~SIZE[~TYPO]-1 : (~LIT[0]-~SYM[2])*~SIZE[~TYPEL[~TYPO]]] |
| 305 |
}; |
| 306 |
end |
| 307 |
~ENDGENERATE |
| 308 |
// rotateLeftS end |
| 309 |
workInfo: Never |
| 310 |
- BlackBox: |
| 311 |
name: Clash.Sized.Vector.rotateRightS |
| 312 |
kind: Declaration |
| 313 |
type: 'rotateRightS :: KnownNat n => Vec n a -> SNat d -> Vec n a' |
| 314 |
template: |- |
| 315 |
// rotateRightS begin |
| 316 |
localparam ~GENSYM[shift_amount][2] = ~LIT[2] % ~LIT[0]; |
| 317 |
|
| 318 |
~GENERATE |
| 319 |
if (~SYM[2] == 0) begin : ~GENSYM[no_shift][3] |
| 320 |
assign ~RESULT = ~VAR[vec][1]; |
| 321 |
end else begin : ~GENSYM[do_shift][4] |
| 322 |
assign ~RESULT = {~VAR[vec][1][(~SYM[2]*~SIZE[~TYPEL[~TYPO]])-1 : 0] |
| 323 |
,~VAR[vec][1][~SIZE[~TYPO]-1 : ~SYM[2]*~SIZE[~TYPEL[~TYPO]]] |
| 324 |
}; |
| 325 |
end |
| 326 |
~ENDGENERATE |
| 327 |
// rotateRightS end |
| 328 |
workInfo: Never |