da4ml 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

da4ml/trace/tracer.py

@@ -1,5 +1,6 @@
 from collections.abc import Sequence
 from decimal import Decimal
+from itertools import chain
 from math import log2
 from typing import overload
 from uuid import UUID
@@ -11,20 +12,20 @@ from .fixed_variable import FixedVariable, _const_f
 from .fixed_variable_array import FixedVariableArray
 
 
-def _recursive_trace(v: FixedVariable, gathered: dict[UUID, FixedVariable]):
-    if v in gathered:
+def _recursive_gather(v: FixedVariable, gathered: dict[UUID, FixedVariable]):
+    if v.id in gathered:
         return
     assert v._from is not None
     for _v in v._from:
         if _v.id not in gathered:
-            _recursive_trace(_v, gathered)
+            _recursive_gather(_v, gathered)
     gathered[v.id] = v
 
 
 def gather_variables(inputs: Sequence[FixedVariable], outputs: Sequence[FixedVariable]):
     gathered = {v.id: v for v in inputs}
     for o in outputs:
-        _recursive_trace(o, gathered)
+        _recursive_gather(o, gathered)
 
     variables = list(gathered.values())
 
@@ -85,6 +86,19 @@ def _comb_trace(inputs: Sequence[FixedVariable], outputs: Sequence[FixedVariable
                 qint = QInterval(qint.min, qint.min, step)
                 data = qint.min / step
                 ops.append(Op(-1, -1, 5, int(data), qint, v.latency, v.cost))
+            case 'msb_mux':
+                qint = v.unscaled.qint
+                key, in0, in1 = v._from
+                opcode = 6 if in1._factor > 0 else -6
+                idk, id0, id1 = index[key.id], index[in0.id], index[in1.id]
+                f0, f1 = in0._factor, in1._factor
+                shift = int(log2(abs(f1 / f0)))
+                data = idk + (shift << 32)
+                assert idk < i and id0 < i and id1 < i
+                assert key._factor > 0, f'Cannot mux on v{key.id} with negative factor {key._factor}'
+                op = Op(id0, id1, opcode, data, qint, v.latency, v.cost)
+                ops.append(op)
+
             case _:
                 raise NotImplementedError(f'Operation "{v.opr}" is not supported in tracing')
     out_index = [index[v.id] for v in outputs]
@@ -101,8 +115,15 @@ def comb_trace(inputs: FixedVariableArray, outputs: FixedVariableArray) -> Solut
 
 def comb_trace(inputs, outputs):
     inputs, outputs = list(np.ravel(inputs)), list(np.ravel(outputs))
-    # latency = max(v.latency if isinstance(v, FixedVariable) else 0 for v in outputs)
-    # outputs = [v if isinstance(v, FixedVariable) else FixedVariable(v,v,0, latency=latency, opr='const') for v in outputs]
+
+    if any(not isinstance(v, FixedVariable) for v in outputs):
+        hwconf = inputs[0].hwconf
+        latency = max(v.latency for v in chain(inputs, outputs) if isinstance(v, FixedVariable))
+        outputs = list(outputs)
+        for i, v in enumerate(outputs):
+            if not isinstance(v, FixedVariable):
+                outputs[i] = FixedVariable.from_const(v, hwconf, latency, 1)
+
     ops, out_index = _comb_trace(inputs, outputs)
     shape = len(inputs), len(outputs)
     inp_shift = [0] * shape[0]
@@ -110,7 +131,7 @@ def comb_trace(inputs, outputs):
     out_shift = [int(log2(abs(sf))) for sf in out_sf]
     out_neg = [sf < 0 for sf in out_sf]
 
-    return Solution(
+    sol = Solution(
         shape,
         inp_shift,
         out_index,
@@ -120,3 +141,12 @@ def comb_trace(inputs, outputs):
         outputs[0].hwconf.carry_size,
         outputs[0].hwconf.adder_size,
     )
+
+    ref_count = sol.ref_count
+
+    for i in range(len(ops)):
+        if ref_count[i] == 0:
+            op = ops[i]
+            sol.ops[i] = Op(-1, -1, op[2], 0, QInterval(0, 0, 1), op[5], op[6])
+
+    return sol

da4ml-0.3.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: da4ml
+Version: 0.3.0
+Summary: Digital Arithmetic for Machine Learning
+Author-email: Chang Sun <chsun@cern.ch>
+License: GNU Lesser General Public License v3 (LGPLv3)
+Project-URL: repository, https://github.com/calad0i/da4ml
+Keywords: CMVM,distributed arithmetic,hls4ml,MCM,subexpression elimination
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: llvmlite>=0.44
+Requires-Dist: numba>=0.61
+Dynamic: license-file
+
+# da4ml: Distributed Arithmetic for Machine Learning
+
+This project performs Constant Matrix-Vector Multiplication (CMVM) with Distributed Arithmetic (DA) for Machine Learning (ML) on a Field Programmable Gate Arrays (FPGAs).
+
+CMVM optimization is done through greedy CSE of two-term subexpressions, with possible Delay Constraints (DC). The optimization is done in jitted Python (Numba), and a list of optimized operations is generated as traced Python code.
+
+The project generates Verilog or Vitis HLS code for the optimized CMVM operations. This project can be used in conjunction with [`hls4ml`](https://github.com/fastmachinelearning/hls4ml/) for optimizing the neural networks deployed on FPGAs. For a subset of neural networks, the full design can be generated standalone in Verilog or Vitis HLS.
+
+
+## Installation
+
+The project is available on PyPI and can be installed with pip:
+
+```bash
+pip install da4ml
+```
+
+Notice that `numba>=6.0.0` is required for the project to work. The project does not work with `python<3.10`. If the project fails to compile, try upgrading `numba` and `llvmlite` to the latest versions.
+
+## `hls4ml`
+
+The major use of this project is through the `distributed_arithmetic` strategy in the `hls4ml`:
+
+```python
+model_hls = hls4ml.converters.convert_from_keras_model(
+    model,
+    hls_config={
+        'Model': {
+            ...
+            'Strategy': 'distributed_arithmetic',
+        },
+        ...
+    },
+    ...
+)
+```
+
+Currently, `Dense/Conv1D/Conv2D` layers are supported for both `io_parallel` and `io_stream` dataflows. However, notice that distributed arithmetic implies `reuse_factor=1`, as the whole kernel is implemented in combinational logic.
+
+## Standalone usage
+
+### `HGQ2`
+
+For some models trained with `HGQ2`, the `da4ml` can be used to generate the whole model in Verilog or Vitis HLS:
+
+```python
+from da4ml.codegen import HLSModel, VerilogModel
+from da4ml.converter.hgq2.parser import trace_model
+from da4ml.trace import comb_trace
+
+inp, out = trace_model(hgq2_model)
+comb_logic = comb_trace(inp[0], out[0]) # Currently, only models with 1 input and 1 output are supported
+
+# Pipelined Verilog model generation
+# `latency_cutoff` is used to control auto piplining behavior. To disable pipelining, set it to -1.
+verilog_model = VerilogModel(sol, prj_name='barbar', path='/tmp/barbar', latency_cutoff=5)
+verilog_model.compile() # write and verilator binding
+verilog_model.predict(inputs)
+
+vitis_hls_model = HLSModel(sol, prj_name='foo', path='/tmp/foo', flavor='vitis') # Only vitis is supported for now
+vitis_hls_model.compile() # write and hls binding
+vitis_hls_model.predict(inputs)
+```
+
+### Functional Definition
+For generic operations, one can define a combinational logic with the functional API:
+
+```python
+from da4ml.trace import FixedVariableArray, HWConfig, comb_trace
+from da4ml.trace.ops import einsum, relu, quantize, conv, pool
+
+# k, i, f are numpy arrays of integers: keep_negative (0/1), integer bits (excl. sign), fractional bits
+inp = FixedVariableArray.from_kif(k, i, f, HWConfig(1, -1, -1), solver_options={'hard_dc':2})
+out = inp @ kernel
+out = relu(out)
+out = einsum(equation, out, weights)
+...
+
+comb = comb_trace(inp, out)
+```
+
+`+`, `-`, `@` are supported as well as `einsum`, `relu`, `quantize` (WRAP, with TRN or RND), `conv`, `pool` (average only). For multiplications, only power-of-two multipliers are supported, otherwise use `einsum` or `@` operators.
+
+The `comb_trace` returns a `Solution` objects that contains a list of low-level operations that are used to implement the combinational logic, which in turn can be used to generate Verilog or Vitis HLS code.

da4ml-0.3.0.dist-info/RECORD

@@ -0,0 +1,64 @@
+da4ml/__init__.py,sha256=IETRRvzsJvPMLu1kzzi8UN5FYaM5MhNaXH2A_ZKr2_w,469
+da4ml/_version.py,sha256=AGmG_Lx0-9ztFw_7d9mYbaYuC-2abxE1oXOUNAY29YY,511
+da4ml/cmvm/__init__.py,sha256=4Tbt913k9zP0w8R1p6Oss06v5jrManbUhskyHl6e-U0,154
+da4ml/cmvm/api.py,sha256=JpecMt6g8zutGh_uWT61_0iX8TuXct7-jq7N7HMIsgA,9626
+da4ml/cmvm/types.py,sha256=hdthYdP5muIQ-9qFE0CjObGT7lCxB1-udXU16LxtuBI,20959
+da4ml/cmvm/core/__init__.py,sha256=bp2CXI4EOVOQSho1qwfusNs0RliZRt2dV0hZ33W_Kjo,7703
+da4ml/cmvm/core/indexers.py,sha256=QjXgvExS-B2abHTJPDG4NufMdMEflo1i6cUhFOgJpH4,2945
+da4ml/cmvm/core/state_opr.py,sha256=wLqO8qVuM2-qCE5LDeYJDNkUruIPHy63obsv4-x-aR8,8661
+da4ml/cmvm/util/__init__.py,sha256=DkBlUEKA_Gu7n576ja_xZlAQfToWmNL9VXU-jmj6a-g,145
+da4ml/cmvm/util/bit_decompose.py,sha256=SUco70HRYf4r1JU6BXwcgabDrhm_yAmucae5FC67i4I,2216
+da4ml/cmvm/util/mat_decompose.py,sha256=eSJNlXwx_jxgqt5vLJrSLQaeq2ZXu8j9mC4d-eq883M,4094
+da4ml/codegen/__init__.py,sha256=Chdh3oO_vLR4saLbT9VxBPz_0wlEzxJldFSZaVUJo7U,331
+da4ml/codegen/cpp/__init__.py,sha256=SIePoi_T4iJph50OQUosAnaVuLCckukYjLxp91Y8xQs,134
+da4ml/codegen/cpp/cpp_codegen.py,sha256=6lBF1I-xXdIABEWF60owBmQiISuI6mrITCqLqhsEHrQ,6033
+da4ml/codegen/cpp/hls_model.py,sha256=J5lnB8sAvMy0Bo5MSJOpgyUm1tzEJqBxgPTlOd38Gbg,8978
+da4ml/codegen/cpp/source/binder_util.hh,sha256=pBVmhXIDvdCr8n2wwYehc3Fpp60sWYrrZaDoP3x9JZE,1880
+da4ml/codegen/cpp/source/build_binder.mk,sha256=RLu4TP28aJsveyMOHxuDRGEJVoIPMo9T8WyPtqnmtbQ,584
+da4ml/codegen/cpp/source/vitis_bitshift.hh,sha256=yFpYCVJ8gof-EzPjkIWWZYmdFh_wk133Pxzs7f61IQo,774
+da4ml/codegen/cpp/source/ap_types/ap_binary.h,sha256=yOcafu2IofstDqxn0wDq8vY3JIwZQ9H5z6IY1dEqMr0,2764
+da4ml/codegen/cpp/source/ap_types/ap_common.h,sha256=1hJY9uvKOdwRSSll5uehUISZR4tsSsQ1z4PNRUc44KU,10180
+da4ml/codegen/cpp/source/ap_types/ap_decl.h,sha256=z1HsH-2RSvSoofTZR7RHeqIfAnEYVuHcIu_ute9gjEg,6473
+da4ml/codegen/cpp/source/ap_types/ap_fixed.h,sha256=3ld4qyF475nDto57AHcsLd-PfoJ7dlplDoZPLXIo6d4,12185
+da4ml/codegen/cpp/source/ap_types/ap_fixed_base.h,sha256=Cd1AJQZjHxVKbvo4w9a9ylkEyNjdXHR7VF9iUoGTb0o,85182
+da4ml/codegen/cpp/source/ap_types/ap_fixed_ref.h,sha256=TO9yZqdWf0VksXmG4SN9_n_CDYQVWU4yuja0YfkrQCw,27302
+da4ml/codegen/cpp/source/ap_types/ap_fixed_special.h,sha256=yXfQnjAc8vJv5T6R9a4L_eA0U_a0ypzK_RSn8yqzt_s,6985
+da4ml/codegen/cpp/source/ap_types/ap_int.h,sha256=nTiyrFN8IPCGRs5RYpCkLT9y4IxaqoRUHtIbpUiOLNA,10012
+da4ml/codegen/cpp/source/ap_types/ap_int_base.h,sha256=Kt4QjfUW85r8lxjY4ESqelR_CnpM0ubb4K5d2G03GMQ,71735
+da4ml/codegen/cpp/source/ap_types/ap_int_ref.h,sha256=5rsOdablweC9hKGtQ8Kktr077sEQ91gzSH5G5hM7m5Y,55218
+da4ml/codegen/cpp/source/ap_types/ap_int_special.h,sha256=HIvRRuiKGpAnCpigURX0cOQUX88dbp3lGkUWpbglMCI,6301
+da4ml/codegen/cpp/source/ap_types/ap_shift_reg.h,sha256=wqe8j3ikbdZiXwYsYlAsFbOFeQLhYXIbKoRC6fJGeuc,4894
+da4ml/codegen/cpp/source/ap_types/hls_math.h,sha256=abFBoZzYjm_pfC2wkuclVh1HuvYJ_YobnN-1Q99GRic,674
+da4ml/codegen/cpp/source/ap_types/hls_stream.h,sha256=NTkVfbE48c6XnMIfR9WzJbDwUnfe6y19xJXxBS3G--I,7480
+da4ml/codegen/cpp/source/ap_types/etc/ap_private.h,sha256=TDdxGIX0r3D6Ql8KeXoceRmHhdlwFA3Akr3-vvMVAtk,261465
+da4ml/codegen/cpp/source/ap_types/utils/x_hls_utils.h,sha256=x24cf1HyZKv0J8YQIoUvYE3uw6SNL7vWetRGIiFm2Jw,2227
+da4ml/codegen/verilog/__init__.py,sha256=rXmW2V9sDp2RYMDAWlhj_gfMXH3G5lPNmLrFtsJjn_A,298
+da4ml/codegen/verilog/comb.py,sha256=CmCwiddeiT4TCZV088lF2ENlAXx3vjZKszTz1sYXEao,7614
+da4ml/codegen/verilog/io_wrapper.py,sha256=SSs-ZRhBVLR6tpFso8GNGk-FH6JDe-p7LPvVPjTspxo,5002
+da4ml/codegen/verilog/pipeline.py,sha256=YsPRTLp04Aofg33QMw6_ga3fNX9LeCD7Pq2PnERLWOg,2377
+da4ml/codegen/verilog/verilog_model.py,sha256=_50dggtH24xMdI0beuyvdsv8G8dlB4MWa1m8KWZQdNE,12295
+da4ml/codegen/verilog/source/binder_util.hh,sha256=Dn9ysUdonw0HR8bxom8YfQF7vc1LEvT_B1V_o8Gw1rY,2503
+da4ml/codegen/verilog/source/build_binder.mk,sha256=rQbI98itE_b1wIQ_0uCXfBzNmGK2XT4vWmRyCJNnPKk,960
+da4ml/codegen/verilog/source/build_prj.tcl,sha256=bcFCpcHR26TJGOQZEpUx0eM1SEiJOCoH-9EPpIvqWu0,3124
+da4ml/codegen/verilog/source/ioutil.hh,sha256=1o1-oIyQyYc9CU91bBxuitVzzcrNT8p4MTarFKiJoG4,3967
+da4ml/codegen/verilog/source/mux.v,sha256=1PMSQKGR_Cku1EQnePBVCuX6we_dqYBXW54WBEURvs0,1928
+da4ml/codegen/verilog/source/negative.v,sha256=YphTCLnYslktsnCPq1xjbYgIFavani5NBbqs20uwhBI,688
+da4ml/codegen/verilog/source/shift_adder.v,sha256=qrpXBX9bhHI-o75v5zshOfq0giEATvbeGgTir20_S3Q,1915
+da4ml/codegen/verilog/source/template.xdc,sha256=GlSRy8tw_orohSuUwUSNEYJLLkAAHttGTfLTcQqRQDg,1262
+da4ml/converter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+da4ml/converter/hgq2/parser.py,sha256=bAtnEXQxRKU9a1HFJWTy-e_HDzZY_wXOBVdyYG3ndsM,3826
+da4ml/converter/hgq2/replica.py,sha256=9ICJGfK2Q2C_glwE0KMcvXttuWvJYRblkO7RLmalzss,13829
+da4ml/trace/__init__.py,sha256=dv-rti3t8iE0RqeThfOb40mAg8FZB2WkkGQq3enJft0,282
+da4ml/trace/fixed_variable.py,sha256=6dfMHBN1NfqYIbPZ79GCPCXj2JFQUKTyDZu6xDaG3rg,17082
+da4ml/trace/fixed_variable_array.py,sha256=A0ApTvZxpkr7kHrUQkyhrGJuuPe4kDgLFyD_1CW7lBk,10985
+da4ml/trace/pipeline.py,sha256=_R2uqWgnpuQ4tD7VKz2eu8CF9Air2RtYH2o03Vfg0Mk,5353
+da4ml/trace/tracer.py,sha256=NqPEH9hyVlGQOf9_kJL3A7SujCcxkT-z28bk0Ael5jE,5664
+da4ml/trace/ops/__init__.py,sha256=I4VqB43lVkFlLtkoWxiSDHBFGvxKwutNbAJw5aLVeAI,2108
+da4ml/trace/ops/conv_utils.py,sha256=P8ccpeHF5D0jY9LdkIfwui3HNs-WpTnGfwiYehtboCU,8246
+da4ml/trace/ops/einsum_utils.py,sha256=MoWvOfvtVjXGwqEhXEzZ3uGrgSmLTHngV8I1eLyANGE,11433
+da4ml/trace/ops/reduce_utils.py,sha256=8gohGQRVr8Bn5rfyrGsnE8EDxUXAObv521qu4mJrX9I,3348
+da4ml-0.3.0.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+da4ml-0.3.0.dist-info/METADATA,sha256=JVugmlP6dRkZ8PZTOisE6OZ3JaNNjm18yKAUBDZC04s,4569
+da4ml-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+da4ml-0.3.0.dist-info/top_level.txt,sha256=N0tnKVwRqFiffFdeAzCgFq71hUNySh5-ITbNd6-R58Q,6
+da4ml-0.3.0.dist-info/RECORD,,

da4ml/codegen/cpp/source/vitis_bridge.h

@@ -1,17 +0,0 @@
-#pragma once
-#include "ap_fixed.h"
-
-template <typename inp_t, typename out_t, size_t SIZE_IN, size_t SIZE_OUT, typename F>
-void vitis_bridge(F f, double *inp, double *out, int size) {
-    inp_t in_fixed_buf[SIZE_IN];
-    out_t out_fixed_buf[SIZE_OUT];
-    for (int i = 0; i < size; i++) {
-        for (int j = 0; j < SIZE_IN; j++) {
-            in_fixed_buf[j] = inp_t(inp[i * SIZE_IN + j]);
-        }
-        f(in_fixed_buf, out_fixed_buf);
-        for (int j = 0; j < SIZE_OUT; j++) {
-            out[i * SIZE_OUT + j] = double(out_fixed_buf[j]);
-        }
-    }
-}

da4ml-0.2.1.dist-info/METADATA

@@ -1,65 +0,0 @@
-Metadata-Version: 2.4
-Name: da4ml
-Version: 0.2.1
-Summary: Digital Arithmetic for Machine Learning
-Author-email: Chang Sun <chsun@cern.ch>
-License: GNU Lesser General Public License v3 (LGPLv3)
-Project-URL: repository, https://github.com/calad0i/da4ml
-Keywords: CMVM,distributed arithmetic,hls4ml,MCM,subexpression elimination
-Classifier: Development Status :: 4 - Beta
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: llvmlite>=0.44
-Requires-Dist: numba>=0.61
-Dynamic: license-file
-
-# da4ml: Distributed Arithmetic for Machine Learning
-
-This project performs Constant Matrix-Vector Multiplication (CMVM) with Distributed Arithmetic (DA) for Machine Learning (ML) on a Field Programmable Gate Arrays (FPGAs).
-
-CMVM optimization is done through greedy CSE of two-term subexpressions, with possible Delay Constraints (DC). The optimization is done in jitted Python (Numba), and a list of optimized operations is generated as traced Python code.
-
-At the moment, the project only generates Vitis HLS C++ code for the FPGA implementation of the optimized CMVM kernel. HDL code generation is planned for the future. Currently, the major use of this repository is through the `distributed_arithmetic` strategy in the [`hls4ml`](https://github.com/fastmachinelearning/hls4ml/) project.
-
-
-## Installation
-
-The project is available on PyPI and can be installed with pip:
-
-```bash
-pip install da4ml
-```
-
-Notice that `numba>=6.0.0` is required for the project to work. The project does not work with `python<3.10`. If the project fails to compile, try upgrading `numba` and `llvmlite` to the latest versions.
-
-## `hls4ml`
-
-The major use of this project is through the `distributed_arithmetic` strategy in the `hls4ml`:
-
-```python
-model_hls = hls4ml.converters.convert_from_keras_model(
-    model,
-    hls_config={
-        'Model': {
-            ...
-            'Strategy': 'distributed_arithmetic',
-        },
-        ...
-    },
-    ...
-)
-```
-
-Currently, `Dense/Conv1D/Conv2D` layers are supported for both `io_parallel` and `io_stream` dataflows. However, notice that distributed arithmetic implies `reuse_factor=1`, as the whole kernel is implemented in combinational logic.
-
-### Notice
-
-Currently, only the `da4ml-v3` branch of `hls4ml` supports the `distributed_arithmetic` strategy. The `da4ml-v3` branch is not yet merged into the `main` branch of `hls4ml`, so you need to install it from the GitHub repository.

da4ml-0.2.1.dist-info/RECORD

@@ -1,39 +0,0 @@
-da4ml/__init__.py,sha256=IETRRvzsJvPMLu1kzzi8UN5FYaM5MhNaXH2A_ZKr2_w,469
-da4ml/_version.py,sha256=UoNvMtd4wCG76RwoSpNCUtaFyTwakGcZolfjXzNVSMY,511
-da4ml/cmvm/__init__.py,sha256=4Tbt913k9zP0w8R1p6Oss06v5jrManbUhskyHl6e-U0,154
-da4ml/cmvm/api.py,sha256=JpecMt6g8zutGh_uWT61_0iX8TuXct7-jq7N7HMIsgA,9626
-da4ml/cmvm/types.py,sha256=MckE6hBnRX2bMvT86CjvyxAMSK7grCrCRn2f_f3qgAw,17844
-da4ml/cmvm/core/__init__.py,sha256=bp2CXI4EOVOQSho1qwfusNs0RliZRt2dV0hZ33W_Kjo,7703
-da4ml/cmvm/core/indexers.py,sha256=QjXgvExS-B2abHTJPDG4NufMdMEflo1i6cUhFOgJpH4,2945
-da4ml/cmvm/core/state_opr.py,sha256=wLqO8qVuM2-qCE5LDeYJDNkUruIPHy63obsv4-x-aR8,8661
-da4ml/cmvm/util/__init__.py,sha256=DkBlUEKA_Gu7n576ja_xZlAQfToWmNL9VXU-jmj6a-g,145
-da4ml/cmvm/util/bit_decompose.py,sha256=SUco70HRYf4r1JU6BXwcgabDrhm_yAmucae5FC67i4I,2216
-da4ml/cmvm/util/mat_decompose.py,sha256=eSJNlXwx_jxgqt5vLJrSLQaeq2ZXu8j9mC4d-eq883M,4094
-da4ml/codegen/__init__.py,sha256=g58EgubgPPoiwRTBduSzm6hAc-poPcK6egdoECfPx9o,329
-da4ml/codegen/cpp/__init__.py,sha256=Tw4XeU_oJsyUkTrsfEPuZ-r0rGAo8E2NX5wn_VTA7NM,90
-da4ml/codegen/cpp/cpp_codegen.py,sha256=FnVPgD8McFFdrecdI1u_ybDLQ0RFuVpJ0xO5Ne1D8j0,4811
-da4ml/codegen/cpp/source/vitis.h,sha256=ovEefBOfW5-PXuDdRObPGNokGGFHiixDCpPWeTN6aTo,765
-da4ml/codegen/cpp/source/vitis_bridge.h,sha256=XvvGw3A4eAaXKi5jp50bMKUsNfd5iQ-HhUKtsty1uns,567
-da4ml/codegen/verilog/__init__.py,sha256=obRTdtMWhPHsxFHg2ADoPd3iDBEX8nk_6HuCet5EDz0,356
-da4ml/codegen/verilog/comb.py,sha256=EZONCceEvIKHHF8yLY-i2V_U_8THw_dJEQWujjCJ5iI,5592
-da4ml/codegen/verilog/io_wrapper.py,sha256=TrfJpJxU4uPTGW02_uFb7cjhFlhuVjH3rY0iWuf-lYk,8003
-da4ml/codegen/verilog/pipeline.py,sha256=YsPRTLp04Aofg33QMw6_ga3fNX9LeCD7Pq2PnERLWOg,2377
-da4ml/codegen/verilog/verilog_model.py,sha256=xTH4-B3PG0jJtQ84NiADvHgU5JbkMEoz_UGuspMHh4Y,10869
-da4ml/codegen/verilog/source/build_binder.mk,sha256=rQbI98itE_b1wIQ_0uCXfBzNmGK2XT4vWmRyCJNnPKk,960
-da4ml/codegen/verilog/source/build_prj.tcl,sha256=bcFCpcHR26TJGOQZEpUx0eM1SEiJOCoH-9EPpIvqWu0,3124
-da4ml/codegen/verilog/source/ioutils.hh,sha256=1o1-oIyQyYc9CU91bBxuitVzzcrNT8p4MTarFKiJoG4,3967
-da4ml/codegen/verilog/source/shift_adder.v,sha256=l2ofym56Y-_PeeY9fwkcZeW9MzrTL_WxvSTvoWERJrU,1885
-da4ml/codegen/verilog/source/template.xdc,sha256=ON8i-TK96Yo6FoZ66WzcVKELajTF5TBmbWFbEilna2U,1142
-da4ml/trace/__init__.py,sha256=1br9bWeFb33t69k6h1XQ50iJhLCqrRuEHtqEawELp-c,230
-da4ml/trace/fixed_variable.py,sha256=DthYqQJt2JD2t6X9nuNRPi80SQ7XriXdyXqw5CMR95Y,11669
-da4ml/trace/fixed_variable_array.py,sha256=7Ds92DLnVYMK6_G_l6DWCxgWf7Y8frBiyBj-vaqeWKk,6929
-da4ml/trace/pipeline.py,sha256=dYduPBNUeyW2Ws392hZNGJEo0qI5ynpn-iC2n7UVahk,5687
-da4ml/trace/tracer.py,sha256=xEQQNHkJ8VFt8cDFISzhX6fNVi2JVfgfCg2aca80E2c,4597
-da4ml/trace/ops/__init__.py,sha256=qz0DLPUyxBAu08RCN22kCkJj1EPKanC8ey8NB3_K8co,1640
-da4ml/trace/ops/conv_utils.py,sha256=LtgP3iSZ3fNV6QkEVBzT7ixt-7WTdmBDrFTtQ_9D5aE,3638
-da4ml/trace/ops/einsum_utils.py,sha256=miyMyzJwBLpLTEzXU4vErPE1Xk-ckZG0cjhd13MLAuA,11325
-da4ml-0.2.1.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-da4ml-0.2.1.dist-info/METADATA,sha256=4Kj_ehj1jTDa21JMDIsujUwUzpv7csj2oB23ib3y998,2849
-da4ml-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-da4ml-0.2.1.dist-info/top_level.txt,sha256=N0tnKVwRqFiffFdeAzCgFq71hUNySh5-ITbNd6-R58Q,6
-da4ml-0.2.1.dist-info/RECORD,,