clash-vhdl-0.6: primitives/CLaSH.Sized.Vector.json

[ { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.eq#"
    , "type"      : "eq# :: Eq a => Vec n a -> Vec n a -> Bool"
    , "templateE" : "~ARG[1] = ~ARG[2]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.neq#"
    , "type"      : "neq# :: Eq a => Vec n a -> Vec n a -> Bool"
    , "templateE" : "~ARG[1] /= ~ARG[2]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.head"
    , "type"      : "head :: Vec (n + 1) a -> a"
    , "templateD" :
"-- head begin
head_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];
  ~RESULT <= ~SYM[1](0);
end block;
-- head end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.tail"
    , "type"      : "tail :: Vec (n + 1) a -> Vec n a"
    , "templateD" :
"-- tail begin
tail_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];
  ~RESULT <= ~SYM[1](1 to ~SYM[1]'high);
end block;
-- tail end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.last"
    , "type"      : "Vec (n + 1) a -> a"
    , "templateD" :
"-- last begin
last_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];
  ~RESULT <= ~SYM[1](~SYM[1]'high);
end block;
-- last end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.init"
    , "type"      : "Vec (n + 1) a -> Vec n a"
    , "templateD" :
"-- init begin
init_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];
  ~RESULT <= ~SYM[1](0 to ~SYM[1]'high - 1);
end block;
-- init end"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.select"
    , "type" :
"select :: (CmpNat (i + s) (s * n) ~ GT) -- ARG[0]
        => SNat f                        -- ARG[1]
        -> SNat s                        -- ARG[2]
        -> SNat n                        -- ARG[3]
        -> Vec i a                       -- ARG[4]
        -> Vec n a"
    , "templateD" :
"-- select begin
select_~SYM[0] : block
  signal ~SYM[1] : ~TYP[4];
begin
  ~SYM[1] <= ~ARG[4];

  select_loop : for ~SYM[2] in ~RESULT'range generate
  begin
      ~RESULT(~SYM[2]) <= ~SYM[1](~LIT[1]+(~LIT[2]*~SYM[2]));
  end generate;
end block;
-- select end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.++"
    , "type"      : "(++) :: Vec n a -> Vec m a -> Vec (n + m) a"
    , "templateE" : "~TYPM[0]'(~ARG[0]) & ~TYPM[1]'(~ARG[1])"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.concat"
    , "type"      : "concat :: Vec n (Vec m a) -> Vec (n * m) a"
    , "templateD" :
"-- concat begin
concat_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];

  concat_loop : for ~SYM[2] in ~SYM[1]'range generate
  begin
    ~RESULT(~SYM[2] * ~LENGTH[~TYPEL[~TYP[0]]] to ((~SYM[2]+1) * ~LENGTH[~TYPEL[~TYP[0]]]) - 1) <= ~SYM[1](~SYM[2]);
  end generate;
end block;
-- concat end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.splitAt"
    , "type"      : "splitAt :: SNat m -> Vec (m + n) a -> (Vec m a, Vec n a)"
    , "templateD" :
"-- sliptAt begin
splitAt_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
begin
  ~SYM[1] <= ~ARG[1];
  ~RESULT <= (~SYM[1](~RESULT.~TYPMO_sel0'left to ~RESULT.~TYPMO_sel0'right)
             ,~SYM[1](~RESULT.~TYPMO_sel1'left + ~RESULT.~TYPMO_sel0'length to ~RESULT.~TYPMO_sel1'right + ~RESULT.~TYPMO_sel0'length));
end block;
-- splitAt end"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.unconcat"
    , "type" :
"unconcat :: KnownNat n     -- ARG[0]
          => SNat m         -- ARG[1]
          -> Vec (n * m) a  -- ARG[2]
          -> Vec n (Vec m a)"
    , "templateD" :
"-- unconcat begin
unconcat_~SYM[0] : block
  signal ~SYM[1] : ~TYP[2];
begin
  ~SYM[1] <= ~ARG[2];

  unconcat_loop : for ~SYM[2] in ~RESULT'range generate
  begin
    ~RESULT(~SYM[2]) <= ~SYM[1]((~SYM[2] * ~LIT[1]) to ((~SYM[2] * ~LIT[1]) + ~LIT[1] - 1));
  end generate;
end block;
-- unconcat end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.map"
    , "type"      : "map :: (a -> b) -> Vec n a -> Vec n b"
    , "templateD" :
"-- map begin
map_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
begin
  ~SYM[1] <= ~ARG[1];

  map_loop : for ~SYM[2] in ~RESULT'range generate
  begin
    ~INST 0
      ~OUTPUT <= ~RESULT(~SYM[2])~ ~TYPEL[~TYPO]~
      ~INPUT  <= ~SYM[1](~SYM[2])~ ~TYPEL[~TYP[1]]~
    ~INST
  end generate;
end block;
-- map end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.imap"
    , "type"      : "imap :: KnownNat n => (Index n -> a -> b) -> Vec n a -> Vec n b"
    , "templateD" :
"-- imap begin
imap_~SYM[0] : block
  signal ~SYM[1] : ~TYP[2];

  function max (l,r : in natural) return natural is
  begin
    if l > r then return l;
    else return r;
    end if;
  end function;
begin
  ~SYM[1] <= ~ARG[2];

  imap_loop : for ~SYM[2] in ~RESULT'range generate
  begin
    ~INST 1
      ~OUTPUT <= ~RESULT(~SYM[2])~ ~TYPEL[~TYPO]~
      ~INPUT  <= to_unsigned(~SYM[2],max(1,integer(ceil(log2(real(~LIT[0]))))))~ ~INDEXTYPE[~LIT[0]]~
      ~INPUT  <= ~SYM[1](~SYM[2])~ ~TYPEL[~TYP[2]]~
    ~INST
  end generate;
end block;
-- imap end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.zipWith"
    , "type"      : "zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c"
    , "templateD" :
"-- zipWith begin
zipWith_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
  signal ~SYM[2] : ~TYP[2];
begin
  ~SYM[1] <= ~ARG[1];
  ~SYM[2] <= ~ARG[2];

  zipWith_loop : for ~SYM[3] in ~RESULT'range generate
  begin
    ~INST 0
      ~OUTPUT <= ~RESULT(~SYM[3])~ ~TYPEL[~TYPO]~
      ~INPUT  <= ~SYM[1](~SYM[3])~ ~TYPEL[~TYP[1]]~
      ~INPUT  <= ~SYM[2](~SYM[3])~ ~TYPEL[~TYP[2]]~
    ~INST
  end generate;
end block;
-- zipWith end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.foldr"
    , "type"      : "foldr :: (a -> b -> b) -> b -> Vec n a -> b"
    , "templateD" :
"-- foldr begin~IF ~LENGTH[~TYP[2]] ~THEN
foldr_~SYM[0] : block
  type foldr_res_vec is array (natural range <>) of ~TYP[1];
  signal intermediate_~SYM[2] : foldr_res_vec (0 to ~LENGTH[~TYP[2]]);
  signal xs_~SYM[3] : ~TYP[2];
begin
  intermediate_~SYM[2](~LENGTH[~TYP[2]]) <= ~ARG[1];
  xs_~SYM[3] <= ~ARG[2];

  foldr_loop : for i_~SYM[4] in xs_~SYM[3]'range generate
    ~INST 0
      ~OUTPUT <= intermediate_~SYM[2](i_~SYM[4])~ ~TYP[1]~
      ~INPUT  <= xs_~SYM[3](i_~SYM[4])~ ~TYPEL[~TYP[2]]~
      ~INPUT  <= intermediate_~SYM[2](i_~SYM[4]+1)~ ~TYP[1]~
    ~INST
  end generate;

  ~RESULT <= intermediate_~SYM[2](0);
end block;
~ELSE
~RESULT <= ~ARG[1];
~FI-- foldr end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.fold"
    , "type"      : "fold :: (a -> a -> a) -> Vec (n+1) a -> a"
    , "comment"   : "THIS ONLY WORKS FOR POWER OF TWO LENGTH VECTORS"
    , "templateD" :
"-- fold begin
fold_~SYM[0] : block
  -- given a level and a depth, calculate the corresponding index into the
  -- intermediate array
  function depth2Index (levels,depth : in natural) return natural is
  begin
    return (2 ** levels - 2 ** depth);
  end function;

  signal intermediate_~SYM[1] : ~TYPM[1](0 to (2*~LENGTH[~TYP[1]])-2);
  constant levels : natural := natural (ceil (log2 (real (~LENGTH[~TYP[1]]))));
begin
  -- put input array into the first half of the intermediate array
  intermediate_~SYM[1](0 to ~LENGTH[~TYP[1]]-1) <= ~ARG[1];

  -- Create the tree of instantiated components
  make_tree : if levels /= 0 generate
    tree_depth : for d in levels-1 downto 0 generate
      tree_depth_loop: for i in 0 to (natural(2**d) - 1) generate
        ~INST 0
          ~OUTPUT <= intermediate_~SYM[1](depth2Index(levels+1,d+1)+i)~ ~TYPO~
          ~INPUT  <= intermediate_~SYM[1](depth2Index(levels+1,d+2)+(2*i))~ ~TYPO~
          ~INPUT  <= intermediate_~SYM[1](depth2Index(levels+1,d+2)+(2*i)+1)~ ~TYPO~
        ~INST
      end generate;
    end generate;
  end generate;

  -- The last element of the intermediate array holds the result
  ~RESULT <= intermediate_~SYM[1]((2*~LENGTH[~TYP[1]])-2);
end block;
-- fold end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.index_int"
    , "type"      : "index_int :: KnownNat n => Vec n a -> Int -> a"
    , "templateD" :
"-- index begin
indexVec_~SYM[0] : block
  signal vec       : ~TYP[1];
  signal vec_index : integer range 0 to ~LIT[0]-1;
begin
  vec <= ~ARG[1];

  vec_index <= ~ARG[2]
  -- pragma translate_off
               mod ~LIT[0]
  -- pragma translate_on
               ;

  ~RESULT <= vec(vec_index);
end block;
-- index end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.replace_int"
    , "type"      : "replace_int :: KnownNat n => Vec n a -> Int -> a -> Vec n a"
    , "templateD" :
"-- replace begin
replaceVec_~SYM[0] : block
  signal vec       : ~TYP[1];
  signal vec_index : integer range 0 to ~LIT[0]-1;
  signal din       : ~TYP[3];
begin
  vec <= ~ARG[1];
  vec_index <= ~ARG[2]
  -- pragma translate_off
               mod ~LIT[0]
  -- pragma translate_on
               ;
  din <= ~ARG[3];

  process(vec,vec_index,din)
    variable ivec : ~TYP[1];
  begin
    ivec := vec;
    ivec(vec_index) := din;
    ~RESULT <= ivec;
  end process;
end block;
-- replace end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.maxIndex"
    , "type"      : "maxIndex :: KnownNat n => Vec n a -> Integer"
    , "templateE" : "~LIT[0] - 1"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.length"
    , "type"      : "length :: KnownNat n => Vec n a -> Integer"
    , "templateE" : "~LIT[0]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.replicate"
    , "type"      : "replicate :: SNat n -> a -> Vec n a"
    , "templateE" : "~TYPMO'(0 to ~LIT[0]-1 => ~ARG[1])"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.transpose"
    , "type"      : "transpose :: KnownNat n => Vec m (Vec n a) -> Vec n (Vec m a)"
    , "templateD" :
"-- transpose begin
transpose_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
begin
  ~SYM[1] <= ~ARG[1];

  transpose_outer : for row_index in ~SYM[1]'range generate
    transpose_inner : for col_index in ~RESULT'range generate
      ~RESULT(col_index)(row_index) <= ~SYM[1](row_index)(col_index);
    end generate;
  end generate;
end block;
-- transpose end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.reverse"
    , "type"      : "reverse :: Vec n a -> Vec n a"
    , "templateD" :
"-- reverse begin
reverse_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];

  reverse_loop : for ~SYM[2] in ~SYM[1]'range generate
    ~RESULT(~SYM[1]'high - ~SYM[2]) <= ~SYM[1](~SYM[2]);
  end generate;
end block;
-- reverse end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.lazyV"
    , "type"      : "lazyV :: KnownNat n => Vec n a -> Vec n a"
    , "templateE" : "~ARG[1]"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.concatBitVector#"
    , "type" :
"concatBitVector# :: KnownNat m           -- ARG[0]
                  => Vec n (BitVector m)  -- ARG[1]
                  -> BitVector (n * m)"
    , "templateD" :
"-- concatBitVector begin
concatBitVector_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
begin
  ~SYM[1] <= ~ARG[1];

  concatBitVectorIter_loop : for ~SYM[2] in ~SYM[1]'range generate
    ~RESULT(((~SYM[2] * ~LIT[0]) + ~LIT[0] - 1) downto (~SYM[2] * ~LIT[0])) <= ~TYPMO(~SYM[1](~SYM[1]'high - ~SYM[2]));
  end generate;
end block;
-- concatBitVector end"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.unconcatBitVector#"
    , "type" :
"unconcatBitVector# :: (KnownNat n, KnownNat m) -- (ARG[0],ARG[1])
                    => BitVector (n * m)        -- ARG[2]
                    -> Vec n (BitVector m)"
    , "templateD" :
"-- unconcatBitVector begin
unconcatBitVector_~SYM[0] : block
  signal ~SYM[1] : ~TYP[2];
begin
  ~SYM[1] <= ~ARG[2];

  unconcatBitVectorIter_loop : for ~SYM[2] in ~RESULT'range generate
    ~RESULT(~RESULT'high - ~SYM[2]) <= ~SYM[1](((~SYM[2] * ~LIT[1]) + ~LIT[1] - 1) downto (~SYM[2] * ~LIT[1]));
  end generate;
end block;
-- unconcatBitVector end"
    }
  }
]