diff --git a/b_asic/operation.py b/b_asic/operation.py
index 673fb4c5dcd71f68a6046fb24ecd8328e61661ba..1bdec6e9b11fedb3f56dbee59f8559a177414ac5 100644
--- a/b_asic/operation.py
+++ b/b_asic/operation.py
@@ -59,7 +59,7 @@ class Operation(GraphComponent, SignalSourceProvider):
ports.
Operations can be evaluated independently using evaluate_output().
- Operations may specify how to truncate inputs through truncate_input().
+ Operations may specify how to quantize inputs through quantize_input().
"""
@abstractmethod
@@ -233,7 +233,7 @@ class Operation(GraphComponent, SignalSourceProvider):
delays: Optional[MutableDelayMap] = None,
prefix: str = "",
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Num:
"""
Evaluate the output at the given index of this operation with the given input
@@ -256,7 +256,7 @@ class Operation(GraphComponent, SignalSourceProvider):
bits_override : int, optional
Specifies a word length override when truncating inputs
which ignores the word length specified by the input signal.
- truncate : bool, default: True
+ quantize : bool, default: True
Specifies whether input truncation should be enabled in the first
place. If set to False, input values will be used directly without any
bit truncation.
@@ -288,7 +288,7 @@ class Operation(GraphComponent, SignalSourceProvider):
delays: Optional[MutableDelayMap] = None,
prefix: str = "",
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Sequence[Num]:
"""
Evaluate all outputs of this operation given the input values.
@@ -325,7 +325,7 @@ class Operation(GraphComponent, SignalSourceProvider):
raise NotImplementedError
@abstractmethod
- def truncate_input(self, index: int, value: Num, bits: int) -> Num:
+ def quantize_input(self, index: int, value: Num, bits: int) -> Num:
"""
Truncate the value to be used as input at the given index to a certain bit
length.
@@ -756,7 +756,7 @@ class AbstractOperation(Operation, AbstractGraphComponent):
delays: Optional[MutableDelayMap] = None,
prefix: str = "",
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Num:
if index < 0 or index >= self.output_count:
raise IndexError(
@@ -771,8 +771,8 @@ class AbstractOperation(Operation, AbstractGraphComponent):
values = self.evaluate(
*(
- self.truncate_inputs(input_values, bits_override)
- if truncate
+ self.quantize_inputs(input_values, bits_override)
+ if quantize
else input_values
)
)
@@ -814,7 +814,7 @@ class AbstractOperation(Operation, AbstractGraphComponent):
delays: Optional[MutableDelayMap] = None,
prefix: str = "",
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Sequence[Num]:
return [
self.evaluate_output(
@@ -824,7 +824,7 @@ class AbstractOperation(Operation, AbstractGraphComponent):
delays,
prefix,
bits_override,
- truncate,
+ quantize,
)
for i in range(self.output_count)
]
@@ -931,14 +931,14 @@ class AbstractOperation(Operation, AbstractGraphComponent):
return self.input(0)
# TODO: Fix
- def truncate_input(self, index: int, value: Num, bits: int) -> Num:
+ def quantize_input(self, index: int, value: Num, bits: int) -> Num:
if isinstance(value, (float, int)):
return round(value) & ((2**bits) - 1)
else:
raise TypeError
# TODO: Seems wrong??? - Oscar
- def truncate_inputs(
+ def quantize_inputs(
self,
input_values: Sequence[Num],
bits_override: Optional[int] = None,
@@ -955,10 +955,10 @@ class AbstractOperation(Operation, AbstractGraphComponent):
if bits_override is not None:
if isinstance(value, complex):
raise TypeError(
- "Complex value cannot be truncated to {bits} bits as"
+ "Complex value cannot be quantized to {bits} bits as"
" requested by the signal connected to input #{i}"
)
- value = self.truncate_input(i, value, bits_override)
+ value = self.quantize_input(i, value, bits_override)
args.append(value)
return args
diff --git a/b_asic/signal.py b/b_asic/signal.py
index 6e25543d0faf2622bc050f71d51aa09a1212e969..1a05940a9209aa0142278ddb6c011a03aadb0143 100644
--- a/b_asic/signal.py
+++ b/b_asic/signal.py
@@ -175,7 +175,7 @@ class Signal(AbstractGraphComponent):
def bits(self) -> Optional[int]:
"""
Get the number of bits that this operation using this signal as an
- input should truncate received values to.
+ input should quantize received values to.
None = unlimited.
"""
return self.param("bits")
@@ -184,7 +184,7 @@ class Signal(AbstractGraphComponent):
def bits(self, bits: Optional[int]) -> None:
"""
Set the number of bits that operations using this signal as an input
- should truncate received values to.
+ should quantize received values to.
None = unlimited.
"""
if bits is not None:
diff --git a/b_asic/signal_flow_graph.py b/b_asic/signal_flow_graph.py
index fc12e9193eee84bf3581deaad593dbcafd3a9658..f3dd86df0032ded9c816f4fc93af4b5498b4ed5d 100644
--- a/b_asic/signal_flow_graph.py
+++ b/b_asic/signal_flow_graph.py
@@ -344,7 +344,7 @@ class SFG(AbstractOperation):
delays: Optional[MutableDelayMap] = None,
prefix: str = "",
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Number:
# doc-string inherited
if index < 0 or index >= self.output_count:
@@ -365,8 +365,8 @@ class SFG(AbstractOperation):
# Set the values of our input operations to the given input values.
for op, arg in zip(
self._input_operations,
- self.truncate_inputs(input_values, bits_override)
- if truncate
+ self.quantize_inputs(input_values, bits_override)
+ if quantize
else input_values,
):
op.value = arg
@@ -378,7 +378,7 @@ class SFG(AbstractOperation):
delays,
prefix,
bits_override,
- truncate,
+ quantize,
deferred_delays,
)
while deferred_delays:
@@ -392,7 +392,7 @@ class SFG(AbstractOperation):
delays,
prefix,
bits_override,
- truncate,
+ quantize,
new_deferred_delays,
)
deferred_delays = new_deferred_delays
@@ -1225,7 +1225,7 @@ class SFG(AbstractOperation):
delays: MutableDelayMap,
prefix: str,
bits_override: Optional[int],
- truncate: bool,
+ quantize: bool,
deferred_delays: DelayQueue,
) -> Num:
key_base = (
@@ -1253,7 +1253,7 @@ class SFG(AbstractOperation):
delays,
prefix,
bits_override,
- truncate,
+ quantize,
deferred_delays,
)
else:
@@ -1270,7 +1270,7 @@ class SFG(AbstractOperation):
delays: MutableDelayMap,
prefix: str,
bits_override: Optional[int],
- truncate: bool,
+ quantize: bool,
deferred_delays: DelayQueue,
) -> Num:
input_values = [
@@ -1280,7 +1280,7 @@ class SFG(AbstractOperation):
delays,
prefix,
bits_override,
- truncate,
+ quantize,
deferred_delays,
)
for input_port in src.operation.inputs
@@ -1292,7 +1292,7 @@ class SFG(AbstractOperation):
delays,
key_base,
bits_override,
- truncate,
+ quantize,
)
results[key] = value
return value
diff --git a/b_asic/simulation.py b/b_asic/simulation.py
index 67c6bf3cb5dce6e91492ac23592028eccee2c6e1..1defde586c2cc8d32d80f3a7719b69ee822e93f6 100644
--- a/b_asic/simulation.py
+++ b/b_asic/simulation.py
@@ -121,18 +121,18 @@ class Simulation:
self,
save_results: bool = True,
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Sequence[Num]:
"""Run one iteration of the simulation and return the resulting output values.
"""
- return self.run_for(1, save_results, bits_override, truncate)
+ return self.run_for(1, save_results, bits_override, quantize)
def run_until(
self,
iteration: int,
save_results: bool = True,
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Sequence[Num]:
"""
Run the simulation until its iteration is greater than or equal to the given\
@@ -151,7 +151,7 @@ class Simulation:
self._delays,
"",
bits_override,
- truncate,
+ quantize,
)
if save_results:
for key, value in results.items():
@@ -164,21 +164,21 @@ class Simulation:
iterations: int,
save_results: bool = True,
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Sequence[Num]:
"""
Run a given number of iterations of the simulation and return the output\
values of the last iteration.
"""
return self.run_until(
- self._iteration + iterations, save_results, bits_override, truncate
+ self._iteration + iterations, save_results, bits_override, quantize
)
def run(
self,
save_results: bool = True,
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Sequence[Num]:
"""
Run the simulation until the end of its input arrays and return the output\
@@ -186,7 +186,7 @@ class Simulation:
"""
if self._input_length is None:
raise IndexError("Tried to run unlimited simulation")
- return self.run_until(self._input_length, save_results, bits_override, truncate)
+ return self.run_until(self._input_length, save_results, bits_override, quantize)
@property
def iteration(self) -> int:
diff --git a/b_asic/special_operations.py b/b_asic/special_operations.py
index 6f438299b2fe69ea5f1bfaa4cc2dfb1b320ea687..3dfd763055adb642ad6f031177390bee0738da08 100644
--- a/b_asic/special_operations.py
+++ b/b_asic/special_operations.py
@@ -201,7 +201,7 @@ class Delay(AbstractOperation):
delays: Optional[MutableDelayMap] = None,
prefix: str = "",
bits_override: Optional[int] = None,
- truncate: bool = True,
+ quantize: bool = True,
) -> Num:
if index != 0:
raise IndexError(f"Output index out of range (expected 0-0, got {index})")
@@ -216,8 +216,8 @@ class Delay(AbstractOperation):
if delays is not None:
value = delays.get(key, value)
delays[key] = (
- self.truncate_inputs(input_values, bits_override)[0]
- if truncate
+ self.quantize_inputs(input_values, bits_override)[0]
+ if quantize
else input_values[0]
)
if results is not None:
diff --git a/legacy/simulation_oop/custom_operation.cpp b/legacy/simulation_oop/custom_operation.cpp
index 03fbb4b7c8b8790c0004b885736609d9be4d6667..4ea7df0d25e525cfeed0b11dea1980a9194543af 100644
--- a/legacy/simulation_oop/custom_operation.cpp
+++ b/legacy/simulation_oop/custom_operation.cpp
@@ -5,11 +5,11 @@
namespace asic {
-custom_operation::custom_operation(result_key key, pybind11::object evaluate_output, pybind11::object truncate_input,
+custom_operation::custom_operation(result_key key, pybind11::object evaluate_output, pybind11::object quantize_input,
std::size_t output_count)
: nary_operation(std::move(key))
, m_evaluate_output(std::move(evaluate_output))
- , m_truncate_input(std::move(truncate_input))
+ , m_quantize_input(std::move(quantize_input))
, m_output_count(output_count) {}
std::size_t custom_operation::output_count() const noexcept {
@@ -19,11 +19,11 @@ std::size_t custom_operation::output_count() const noexcept {
number custom_operation::evaluate_output_impl(std::size_t index, evaluation_context const& context) const {
using namespace pybind11::literals;
auto input_values = this->evaluate_inputs(context);
- return m_evaluate_output(index, std::move(input_values), "truncate"_a = false).cast<number>();
+ return m_evaluate_output(index, std::move(input_values), "quantize"_a = false).cast<number>();
}
-number custom_operation::truncate_input(std::size_t index, number value, std::size_t bits) const {
- return m_truncate_input(index, value, bits).cast<number>();
+number custom_operation::quantize_input(std::size_t index, number value, std::size_t bits) const {
+ return m_quantize_input(index, value, bits).cast<number>();
}
} // namespace asic
diff --git a/legacy/simulation_oop/custom_operation.hpp b/legacy/simulation_oop/custom_operation.hpp
index 12a2a107b7b08c9e6752e61759cb0092937e1eba..241b3698aa5e09acaa8927cd9cfed694af590a37 100644
--- a/legacy/simulation_oop/custom_operation.hpp
+++ b/legacy/simulation_oop/custom_operation.hpp
@@ -18,16 +18,16 @@ namespace asic {
class custom_operation final : public nary_operation {
public:
- custom_operation(result_key key, pybind11::object evaluate_output, pybind11::object truncate_input, std::size_t output_count);
+ custom_operation(result_key key, pybind11::object evaluate_output, pybind11::object quantize_input, std::size_t output_count);
[[nodiscard]] std::size_t output_count() const noexcept final;
private:
[[nodiscard]] number evaluate_output_impl(std::size_t index, evaluation_context const& context) const final;
- [[nodiscard]] number truncate_input(std::size_t index, number value, std::size_t bits) const final;
+ [[nodiscard]] number quantize_input(std::size_t index, number value, std::size_t bits) const final;
pybind11::object m_evaluate_output;
- pybind11::object m_truncate_input;
+ pybind11::object m_quantize_input;
std::size_t m_output_count;
};
diff --git a/legacy/simulation_oop/operation.cpp b/legacy/simulation_oop/operation.cpp
index 57a187f8485ceb3f27ee2aceee1fede7c9b4e615..8ba049545f125f47bd6d83128540816a718c1e21 100644
--- a/legacy/simulation_oop/operation.cpp
+++ b/legacy/simulation_oop/operation.cpp
@@ -57,14 +57,14 @@ number abstract_operation::evaluate_output(std::size_t index, evaluation_context
return value;
}
-number abstract_operation::truncate_input(std::size_t index, number value, std::size_t bits) const {
+number abstract_operation::quantize_input(std::size_t index, number value, std::size_t bits) const {
if (value.imag() != 0) {
throw py::type_error{
- fmt::format("Complex value cannot be truncated to {} bits as requested by the signal connected to input #{}", bits, index)};
+ fmt::format("Complex value cannot be quantized to {} bits as requested by the signal connected to input #{}", bits, index)};
}
if (bits > 64) {
throw py::value_error{
- fmt::format("Cannot truncate to {} (more than 64) bits as requested by the singal connected to input #{}", bits, index)};
+ fmt::format("Cannot quantize to {} (more than 64) bits as requested by the singal connected to input #{}", bits, index)};
}
return number{static_cast<number::value_type>(static_cast<std::int64_t>(value.real()) & ((std::int64_t{1} << bits) - 1))};
}
@@ -101,7 +101,7 @@ signal_source const& unary_operation::input() const noexcept {
number unary_operation::evaluate_input(evaluation_context const& context) const {
auto const value = m_in.evaluate_output(context);
auto const bits = context.bits_override.value_or(m_in.bits().value_or(0));
- return (context.truncate && bits != 0) ? this->truncate_input(0, value, bits) : value;
+ return (context.quantize && bits != 0) ? this->quantize_input(0, value, bits) : value;
}
binary_operation::binary_operation(result_key key)
@@ -123,13 +123,13 @@ signal_source const& binary_operation::rhs() const noexcept {
number binary_operation::evaluate_lhs(evaluation_context const& context) const {
auto const value = m_lhs.evaluate_output(context);
auto const bits = context.bits_override.value_or(m_lhs.bits().value_or(0));
- return (context.truncate && bits != 0) ? this->truncate_input(0, value, bits) : value;
+ return (context.quantize && bits != 0) ? this->quantize_input(0, value, bits) : value;
}
number binary_operation::evaluate_rhs(evaluation_context const& context) const {
auto const value = m_rhs.evaluate_output(context);
auto const bits = context.bits_override.value_or(m_rhs.bits().value_or(0));
- return (context.truncate && bits != 0) ? this->truncate_input(0, value, bits) : value;
+ return (context.quantize && bits != 0) ? this->quantize_input(0, value, bits) : value;
}
nary_operation::nary_operation(result_key key)
@@ -149,7 +149,7 @@ std::vector<number> nary_operation::evaluate_inputs(evaluation_context const& co
for (auto const& input : m_inputs) {
auto const value = input.evaluate_output(context);
auto const bits = context.bits_override.value_or(input.bits().value_or(0));
- values.push_back((context.truncate && bits != 0) ? this->truncate_input(0, value, bits) : value);
+ values.push_back((context.quantize && bits != 0) ? this->quantize_input(0, value, bits) : value);
}
return values;
}
diff --git a/legacy/simulation_oop/operation.hpp b/legacy/simulation_oop/operation.hpp
index 086666102a14e32895834c0616af1728e48dc400..cfffdd53ea0e4dec8fe00a96eca7fa21d659f0c2 100644
--- a/legacy/simulation_oop/operation.hpp
+++ b/legacy/simulation_oop/operation.hpp
@@ -30,7 +30,7 @@ struct evaluation_context final {
delay_map* delays = nullptr;
delay_queue* deferred_delays = nullptr;
std::optional<std::size_t> bits_override{};
- bool truncate = false;
+ bool quantize = false;
};
class signal_source final {
@@ -71,7 +71,7 @@ public:
protected:
[[nodiscard]] virtual number evaluate_output_impl(std::size_t index, evaluation_context const& context) const = 0;
- [[nodiscard]] virtual number truncate_input(std::size_t index, number value, std::size_t bits) const;
+ [[nodiscard]] virtual number quantize_input(std::size_t index, number value, std::size_t bits) const;
[[nodiscard]] result_key const& key_base() const;
[[nodiscard]] result_key key_of_output(std::size_t index) const;
diff --git a/legacy/simulation_oop/signal_flow_graph.cpp b/legacy/simulation_oop/signal_flow_graph.cpp
index 5248de741cff3bc7a6e03fc3e479998820c42707..6c60d7b73122903d51ff0a13a051ff717f2a120f 100644
--- a/legacy/simulation_oop/signal_flow_graph.cpp
+++ b/legacy/simulation_oop/signal_flow_graph.cpp
@@ -68,7 +68,7 @@ std::shared_ptr<custom_operation> signal_flow_graph_operation::add_custom_operat
auto const input_count = op.attr("input_count").cast<std::size_t>();
auto const output_count = op.attr("output_count").cast<std::size_t>();
auto new_op = add_operation<custom_operation>(
- op, added, std::move(key), op.attr("evaluate_output"), op.attr("truncate_input"), output_count);
+ op, added, std::move(key), op.attr("evaluate_output"), op.attr("quantize_input"), output_count);
auto inputs = std::vector<signal_source>{};
inputs.reserve(input_count);
for (auto const i : range(input_count)) {
diff --git a/legacy/simulation_oop/simulation.cpp b/legacy/simulation_oop/simulation.cpp
index 7d044c6a8a76b5d845f47342b2a82ec9a241a5b4..62aa55e5025d24066bb562798b025daec7126998 100644
--- a/legacy/simulation_oop/simulation.cpp
+++ b/legacy/simulation_oop/simulation.cpp
@@ -50,12 +50,12 @@ void simulation::set_inputs(
}
}
-std::vector<number> simulation::step(bool save_results, std::optional<std::size_t> bits_override, bool truncate) {
- return this->run_for(1, save_results, bits_override, truncate);
+std::vector<number> simulation::step(bool save_results, std::optional<std::size_t> bits_override, bool quantize) {
+ return this->run_for(1, save_results, bits_override, quantize);
}
std::vector<number> simulation::run_until(iteration_type iteration, bool save_results, std::optional<std::size_t> bits_override,
- bool truncate) {
+ bool quantize) {
auto result = std::vector<number>{};
while (m_iteration < iteration) {
ASIC_DEBUG_MSG("Running simulation iteration.");
@@ -73,7 +73,7 @@ std::vector<number> simulation::run_until(iteration_type iteration, bool save_re
context.delays = &m_delays;
context.deferred_delays = &deferred_delays;
context.bits_override = bits_override;
- context.truncate = truncate;
+ context.quantize = quantize;
for (auto const i : range(m_sfg.output_count())) {
result.push_back(m_sfg.evaluate_output(i, context));
@@ -100,16 +100,16 @@ std::vector<number> simulation::run_until(iteration_type iteration, bool save_re
}
std::vector<number> simulation::run_for(iteration_type iterations, bool save_results, std::optional<std::size_t> bits_override,
- bool truncate) {
+ bool quantize) {
if (iterations > std::numeric_limits<iteration_type>::max() - m_iteration) {
throw py::value_error("Simulation iteration type overflow!");
}
- return this->run_until(m_iteration + iterations, save_results, bits_override, truncate);
+ return this->run_until(m_iteration + iterations, save_results, bits_override, quantize);
}
-std::vector<number> simulation::run(bool save_results, std::optional<std::size_t> bits_override, bool truncate) {
+std::vector<number> simulation::run(bool save_results, std::optional<std::size_t> bits_override, bool quantize) {
if (m_input_length) {
- return this->run_until(*m_input_length, save_results, bits_override, truncate);
+ return this->run_until(*m_input_length, save_results, bits_override, quantize);
}
throw py::index_error{"Tried to run unlimited simulation"};
}
diff --git a/legacy/simulation_oop/simulation.hpp b/legacy/simulation_oop/simulation.hpp
index e10feb990c90ae314576a227d284c5ca2fc4f8ce..f359f4a5fbc7b9db5f306854fc5c4a2df8fc069c 100644
--- a/legacy/simulation_oop/simulation.hpp
+++ b/legacy/simulation_oop/simulation.hpp
@@ -40,12 +40,12 @@ public:
void set_input(std::size_t index, input_provider_type input_provider);
void set_inputs(std::vector<std::optional<input_provider_type>> input_providers);
- [[nodiscard]] std::vector<number> step(bool save_results, std::optional<std::size_t> bits_override, bool truncate);
+ [[nodiscard]] std::vector<number> step(bool save_results, std::optional<std::size_t> bits_override, bool quantize);
[[nodiscard]] std::vector<number> run_until(iteration_type iteration, bool save_results, std::optional<std::size_t> bits_override,
- bool truncate);
+ bool quantize);
[[nodiscard]] std::vector<number> run_for(iteration_type iterations, bool save_results, std::optional<std::size_t> bits_override,
- bool truncate);
- [[nodiscard]] std::vector<number> run(bool save_results, std::optional<std::size_t> bits_override, bool truncate);
+ bool quantize);
+ [[nodiscard]] std::vector<number> run(bool save_results, std::optional<std::size_t> bits_override, bool quantize);
[[nodiscard]] iteration_type iteration() const noexcept;
[[nodiscard]] pybind11::dict results() const noexcept;
diff --git a/src/simulation.cpp b/src/simulation.cpp
index 2f9ccd3df64dd223f695af62a60a550822525b2a..9381925b03c6140e75a48133995e9b06fbee030c 100644
--- a/src/simulation.cpp
+++ b/src/simulation.cpp
@@ -26,20 +26,20 @@ void define_simulation_class(pybind11::module& module) {
"Set the input functions used to get values for the inputs to the internal SFG.")
.def("step", &simulation::step,
- py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("truncate") = true,
+ py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("quantize") = true,
"Run one iteration of the simulation and return the resulting output values.")
.def("run_until", &simulation::run_until,
- py::arg("iteration"), py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("truncate") = true,
+ py::arg("iteration"), py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("quantize") = true,
"Run the simulation until its iteration is greater than or equal to the given iteration\n"
"and return the output values of the last iteration.")
.def("run_for", &simulation::run_for,
- py::arg("iterations"), py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("truncate") = true,
+ py::arg("iterations"), py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("quantize") = true,
"Run a given number of iterations of the simulation and return the output values of the last iteration.")
.def("run", &simulation::run,
- py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("truncate") = true,
+ py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("quantize") = true,
"Run the simulation until the end of its input arrays and return the output values of the last iteration.")
.def_property_readonly("iteration", &simulation::iteration,
diff --git a/src/simulation/compile.cpp b/src/simulation/compile.cpp
index 4b0e7fc813efaea3fba291fad0135f753ff9403b..fd8c204e587f14f3001ede86db22b23eb9c96743 100644
--- a/src/simulation/compile.cpp
+++ b/src/simulation/compile.cpp
@@ -203,9 +203,9 @@ private:
if (!signal.attr("bits").is_none()) {
auto const bits = signal.attr("bits").cast<std::size_t>();
if (bits > 64) {
- throw py::value_error{"Cannot truncate to more than 64 bits"};
+ throw py::value_error{"Cannot quantize to more than 64 bits"};
}
- this->add_instruction(instruction_type::truncate, no_result_index, 0).bit_mask = static_cast<std::int64_t>(
+ this->add_instruction(instruction_type::quantize, no_result_index, 0).bit_mask = static_cast<std::int64_t>(
(std::int64_t{1} << bits) - 1);
}
}
diff --git a/src/simulation/format_code.hpp b/src/simulation/format_code.hpp
index 6b286d0e954289065882c8f795d9bdeb4dea3ed2..b338c325d807068a370b59e807288a762f80aa6b 100644
--- a/src/simulation/format_code.hpp
+++ b/src/simulation/format_code.hpp
@@ -53,7 +53,7 @@ namespace asic {
case instruction_type::push_result: return fmt::format("push_result results[{}]", instruction.index);
case instruction_type::push_delay: return fmt::format("push_delay delays[{}]", instruction.index);
case instruction_type::push_constant: return fmt::format("push_constant {}", format_number(instruction.value));
- case instruction_type::truncate: return fmt::format("truncate {:#018x}", instruction.bit_mask);
+ case instruction_type::quantize: return fmt::format("quantize {:#018x}", instruction.bit_mask);
case instruction_type::addition: return "addition";
case instruction_type::subtraction: return "subtraction";
case instruction_type::multiplication: return "multiplication";
diff --git a/src/simulation/instruction.hpp b/src/simulation/instruction.hpp
index 22d0464d1e7cc19bf47cdd2a01fdd807ce53de6e..9b03d9e0bf8419166483f60e4d3b9a97efb7e875 100644
--- a/src/simulation/instruction.hpp
+++ b/src/simulation/instruction.hpp
@@ -14,7 +14,7 @@ enum class instruction_type : std::uint8_t {
push_result, // push(results[index])
push_delay, // push(delays[index])
push_constant, // push(value)
- truncate, // push(trunc(pop(), bit_mask))
+ quantize, // push(trunc(pop(), bit_mask))
addition, // rhs=pop(), lhs=pop(), push(lhs + rhs)
subtraction, // rhs=pop(), lhs=pop(), push(lhs - rhs)
multiplication, // rhs=pop(), lhs=pop(), push(lhs * rhs)
@@ -39,7 +39,7 @@ struct instruction final {
union {
// Index used by push_input, push_result, delay and custom.
std::size_t index;
- // Bit mask used by truncate.
+ // Bit mask used by quantize.
std::int64_t bit_mask;
// Constant value used by push_constant and constant_multiplication.
number value;
diff --git a/src/simulation/run.cpp b/src/simulation/run.cpp
index da307533b3791e0d2e89cae99a61d107ea5a2301..1998b82ecbcc017961f13f0c1b98fd039b2e7467 100644
--- a/src/simulation/run.cpp
+++ b/src/simulation/run.cpp
@@ -18,27 +18,27 @@ namespace py = pybind11;
namespace asic {
-[[nodiscard]] static number truncate_value(number value, std::int64_t bit_mask) {
+[[nodiscard]] static number quantize_value(number value, std::int64_t bit_mask) {
if (value.imag() != 0) {
- throw py::type_error{"Complex value cannot be truncated"};
+ throw py::type_error{"Complex value cannot be quantized"};
}
return number{static_cast<number::value_type>(static_cast<std::int64_t>(value.real()) & bit_mask)};
}
-[[nodiscard]] static std::int64_t setup_truncation_parameters(bool& truncate, std::optional<std::uint8_t>& bits_override) {
- if (truncate && bits_override) {
- truncate = false; // Ignore truncate instructions, they will be truncated using bits_override instead.
+[[nodiscard]] static std::int64_t setup_truncation_parameters(bool& quantize, std::optional<std::uint8_t>& bits_override) {
+ if (quantize && bits_override) {
+ quantize = false; // Ignore quantize instructions, they will be quantized using bits_override instead.
if (*bits_override > 64) {
- throw py::value_error{"Cannot truncate to more than 64 bits"};
+ throw py::value_error{"Cannot quantize to more than 64 bits"};
}
return static_cast<std::int64_t>((std::int64_t{1} << *bits_override) - 1); // Return the bit mask override to use.
}
- bits_override.reset(); // Don't use bits_override if truncate is false.
+ bits_override.reset(); // Don't use bits_override if quantize is false.
return std::int64_t{};
}
simulation_state run_simulation(simulation_code const& code, span<number const> inputs, span<number> delays,
- std::optional<std::uint8_t> bits_override, bool truncate) {
+ std::optional<std::uint8_t> bits_override, bool quantize) {
ASIC_ASSERT(inputs.size() == code.input_count);
ASIC_ASSERT(delays.size() == code.delays.size());
ASIC_ASSERT(code.output_count <= code.required_stack_size);
@@ -72,8 +72,8 @@ simulation_state run_simulation(simulation_code const& code, span<number const>
return *(stack_pointer - 1);
};
- // Check if results should be truncated.
- auto const bit_mask_override = setup_truncation_parameters(truncate, bits_override);
+ // Check if results should be quantized.
+ auto const bit_mask_override = setup_truncation_parameters(quantize, bits_override);
// Hot instruction evaluation loop.
for (auto const& instruction : code.instructions) {
@@ -92,9 +92,9 @@ simulation_state run_simulation(simulation_code const& code, span<number const>
case instruction_type::push_constant:
push(instruction.value);
break;
- case instruction_type::truncate:
- if (truncate) {
- push(truncate_value(pop(), instruction.bit_mask));
+ case instruction_type::quantize:
+ if (quantize) {
+ push(quantize_value(pop(), instruction.bit_mask));
}
break;
case instruction_type::addition: {
@@ -163,16 +163,16 @@ simulation_state run_simulation(simulation_code const& code, span<number const>
for (auto i = std::size_t{0}; i < op.input_count; ++i) {
input_values.push_back(pop());
}
- push(op.evaluate_output(src.output_index, std::move(input_values), "truncate"_a = truncate).cast<number>());
+ push(op.evaluate_output(src.output_index, std::move(input_values), "quantize"_a = quantize).cast<number>());
break;
}
case instruction_type::forward_value:
// Do nothing, since doing push(pop()) would be pointless.
break;
}
- // If we've been given a global override for how many bits to use, always truncate the result.
+ // If we've been given a global override for how many bits to use, always quantize the result.
if (bits_override) {
- push(truncate_value(pop(), bit_mask_override));
+ push(quantize_value(pop(), bit_mask_override));
}
// Store the result.
state.results[instruction.result_index] = peek();
diff --git a/src/simulation/run.hpp b/src/simulation/run.hpp
index 32c56b3e764c01080bbf28b93ebb4e1fec4d9556..7cc05e5fa68709cfaac662948e751afadd7d37e3 100644
--- a/src/simulation/run.hpp
+++ b/src/simulation/run.hpp
@@ -16,7 +16,7 @@ struct simulation_state final {
};
simulation_state run_simulation(simulation_code const& code, span<number const> inputs, span<number> delays,
- std::optional<std::uint8_t> bits_override, bool truncate);
+ std::optional<std::uint8_t> bits_override, bool quantize);
} // namespace asic
diff --git a/src/simulation/simulation.cpp b/src/simulation/simulation.cpp
index 540505b40d2b09fa301c030ca374102b0d63ba02..34ac320fbde53729a45769efcac806a4f449aac4 100644
--- a/src/simulation/simulation.cpp
+++ b/src/simulation/simulation.cpp
@@ -62,12 +62,12 @@ void simulation::set_inputs(
}
}
-std::vector<number> simulation::step(bool save_results, std::optional<std::uint8_t> bits_override, bool truncate) {
- return this->run_for(1, save_results, bits_override, truncate);
+std::vector<number> simulation::step(bool save_results, std::optional<std::uint8_t> bits_override, bool quantize) {
+ return this->run_for(1, save_results, bits_override, quantize);
}
std::vector<number> simulation::run_until(iteration_type iteration, bool save_results, std::optional<std::uint8_t> bits_override,
- bool truncate) {
+ bool quantize) {
auto result = std::vector<number>{};
while (m_iteration < iteration) {
ASIC_DEBUG_MSG("Running simulation iteration.");
@@ -75,7 +75,7 @@ std::vector<number> simulation::run_until(iteration_type iteration, bool save_re
for (auto&& [input, function] : zip(inputs, m_input_functions)) {
input = function(m_iteration);
}
- auto state = run_simulation(m_code, inputs, m_delays, bits_override, truncate);
+ auto state = run_simulation(m_code, inputs, m_delays, bits_override, quantize);
result = std::move(state.stack);
if (save_results) {
m_results.push_back(std::move(state.results));
@@ -86,16 +86,16 @@ std::vector<number> simulation::run_until(iteration_type iteration, bool save_re
}
std::vector<number> simulation::run_for(iteration_type iterations, bool save_results, std::optional<std::uint8_t> bits_override,
- bool truncate) {
+ bool quantize) {
if (iterations > std::numeric_limits<iteration_type>::max() - m_iteration) {
throw py::value_error("Simulation iteration type overflow!");
}
- return this->run_until(m_iteration + iterations, save_results, bits_override, truncate);
+ return this->run_until(m_iteration + iterations, save_results, bits_override, quantize);
}
-std::vector<number> simulation::run(bool save_results, std::optional<std::uint8_t> bits_override, bool truncate) {
+std::vector<number> simulation::run(bool save_results, std::optional<std::uint8_t> bits_override, bool quantize) {
if (m_input_length) {
- return this->run_until(*m_input_length, save_results, bits_override, truncate);
+ return this->run_until(*m_input_length, save_results, bits_override, quantize);
}
throw py::index_error{"Tried to run unlimited simulation"};
}
diff --git a/src/simulation/simulation.hpp b/src/simulation/simulation.hpp
index e5624cd27a801383a07cd64b54ec5c04028ea5eb..ec930e83a13400ebaf0566154d06a06c8f0d0901 100644
--- a/src/simulation/simulation.hpp
+++ b/src/simulation/simulation.hpp
@@ -28,12 +28,12 @@ public:
void set_input(std::size_t index, input_provider_type input_provider);
void set_inputs(std::vector<std::optional<input_provider_type>> input_providers);
- [[nodiscard]] std::vector<number> step(bool save_results, std::optional<std::uint8_t> bits_override, bool truncate);
+ [[nodiscard]] std::vector<number> step(bool save_results, std::optional<std::uint8_t> bits_override, bool quantize);
[[nodiscard]] std::vector<number> run_until(iteration_type iteration, bool save_results, std::optional<std::uint8_t> bits_override,
- bool truncate);
+ bool quantize);
[[nodiscard]] std::vector<number> run_for(iteration_type iterations, bool save_results, std::optional<std::uint8_t> bits_override,
- bool truncate);
- [[nodiscard]] std::vector<number> run(bool save_results, std::optional<std::uint8_t> bits_override, bool truncate);
+ bool quantize);
+ [[nodiscard]] std::vector<number> run(bool save_results, std::optional<std::uint8_t> bits_override, bool quantize);
[[nodiscard]] iteration_type iteration() const noexcept;
[[nodiscard]] pybind11::dict results() const noexcept;