Energy-Efficient Random Variate Generation via Compressed Lookup Tables
Authors: Johann Ukrow
Anna Kazachkova
Nicolas Alder
Sven Köhler
Rainer Schlosser
Ralf Herbrich
Venue: ICLR 2026 Poster (2026)
Keywords: energy-efficiency
sampling
Primary area: other topics in machine learning (i.e., none of the above)

Abstract: Generating (pseudo-)random variates lies at the core of probabilistic machine learning and prediction algorithms and yet remains a major bottleneck due to its high computational and energy cost. In this paper, we introduce a general and scalable sampling strategy that enables fast and energy-efficient random variate generation from arbitrary distributions. Our approach is based on compressed lookup tables (cLUT) combined with a fast index sampling scheme. Using only a handful of fast and energy-efficient compute operations on simple array structures, we achieve superior speed, energy efficiency, and precision at near-optimal entropy cost compared to state-of-the-art techniques. Microbenchmarking our approach with a C implementation shows up to 40\% savings in time and 50\% in energy compared to state-of-the-art approaches. Compared to commonly employed Python samplers, we achieve a 100$\times$ time improvement.

Published as a conference paper at ICLR 2026
ENERGY-EFFICIENT RANDOM VARIATE GENERATION VIA COMPRESSED LOOKUP TABLES
Johann Ukrow", Anna Kazachkova,, Nicolas Alder, Sven Köhler,
Rainer Schlosser & Ralf Herbrich.
Hasso Plattner Institute
University of Potsdam
Potsdam, Germany
{johann. ukrow, anna. www.aaaaaaaaccaaaaaiiooo nicolas.. sven sven.koehler, rainer schlosser, ralf. heebrichheepi..ee
ABSTRACT
Generating (pseudo-)random )random variates lies at the core of probabilistic machine learning and prediction algorithms and yet remains major bottleneck due its high computational and energy cost. In this paper, we introduce a general and scalable sampling strategy that enables fast and energy-efficient random variate generation from arbitrary distributions. Our approach is based on compressed lookup tables (cL.UT) combined with fast index sampling scheme. Using only handful of fast and energy eefegyeefficient compute operations on simple array struc- tures, we achieve superior speed, energy efficiency, and precision at near-optimal entropy cost compared to slate-of-the-an techniques. Microbenchmarking our ap- proach with a implementation shows up to 40% savings in time and 50% in en- engy compared to tate-of-thee-a aat approaches. Compared to commonly employed Python samplers, we achieve a 100x time improvement.
INTRODUCTION
Sampling from probability distributions is fundamental yet computationally expensive operation in machine learning. In representation learning and in broader machine learning, sampling underpins core methods such variational autoencoders (Kingma and Welling, (022). contrastive learning with negative sampling (Chen et al.) (020), diffusion-basee generative models (Ho et al. 2020b), and probabilistic inference techniques such as Bayesian deep learning (Sommer al. 2025 While the quality and efficiency of sampled variables directly shape the expressiveness and scalability of learned representations, sampling costs often remain a primary barrier scalability and widespread deployment. In this paper. we address this bottleneck by introducing a novel, efficient sampling approach for arbitrary distributions. Our method achieves 10-100x speedups and up to 60% reduc- tion in energy consumption compared to commonly employed approaches, significantly reducing many machine learning tasks.
the resource-intensity
The continued deployment of machine learning methods in data centers, cloud devices, and user appliances alike accompanied by increased concerns about the growing energy demand of the field (International Energy Agency 2025 Gadepally 2025). Countermeasures include reducing the carbon-intensity of the electricity supply or shifting training and inference to times or physical loca- tions with higher share of renewable energy sources throughout the day (Yang et al. 2023 Wiesner et al. 2023). However, we argue that reducing the energy demand the operations themselves is worthwhile, with emphasis frequently performed actions like sampling. Motivating to per- form extensive energy measurements in addition to speed measurements, comparing our method to classical, widely used approaches and recent state-of-the-art advances.
On digital computers, sampling from arbitrary probability distributions is reduced to sampling from finite discrete distributions due to fundamental constraints of finite precision and memory. All prob- ability distributions, whether continuous or infinite discrete, must be discretized for computational
"qqual contribution.

---

Published as a conference paper at ICLR 2026
implementation (see Appendix B for discretization techniques). Standard sampling algorithms in widely used libraries (NumPy. Py Torch, JAX) assume infinite precision arithmetic, where computa- tion can be performed with arbitrarily precise real numbers (Shamos 1978, Devroye 1986 Chapter 2, p. Assumption 1). Additionally, they assume the ability to generate infinitely precise samples from the real unit interval (Devroye 1986, Chapter 2, p.1, Assumption 2). However, actual imple- mentations rely on finite floating- point representations and don't t have access to exact samples from the real unit interval, causing generated distributions to deviate from their intended target distribu- tions in uncontrolled ways. These deviations are often intractable to quantify, precluding theoretical guarantees about sampling accuracy. To address this issue, our proposed sampling method features controllable precision and exactly represents target distributions with clear theoretical guarantees.
Problem formulation In what follows, we will describe a novel method to generate random vari- ates from any finite discrete distribution, represented by n probabilities Pi.....PA E [0, 1] of the corresponding n outcomes 21,..... In E X. As we denote no constraints on the structure of X the outcomes can be of arbitrary types, such as real numbers, strings, pointers to more complex data structures, or any mixture of those. Our objective to make this generation process fast, energy efficient, and adjustable to an arbitrary and controllable precision.
Our contributions This work introduces a new sampling approach for arbitrary distributions based on operations with lookup tables. Besides being a generic method for efficient and arbitrary precise sampling, our approach is especially suitable for situations where floating- operations are either unavailable or too error prone, and situations with low power supply. We summarize our contributions as follows:
1. We propose novel a random variate generator based on compressed lookup tables (cLUT), optimized for highly efficient sampling. We introduce a lossless compression strategy for compact representations of distributions achieving an exponential compression ratio.
2. We compare cLUT against sfate-of-the-at approaches in terms of speed, energy efficiency, memory usage, and entropy efficiency. It runs 30-40% faster and saves 25-50% energy in a diverse set of distributions. For larger distribution sizes, it performs particularly well.
3. We benchmark cLUT against standard sampling routines from widely used Python ma- chine learning libraries. cLUT achieves up to 10-100x acceleration in speed. Furthermore, we illustrate the impact of our approach in real-world machine learning applications by showcasing that cLUT substantially reduces the execution time and energy consumption of the exemplary TrueSkill application.
2 RELATED WORK
Sampling methods are classically divided into two categories: exact methods, which produce sam- ples from the target distribution p as specified, and approximate methods, which generate samples from distribution P that only approximately matches the desired distribution, i.e., p RS p. Note that our approach is exact.
Exact methods Knuth and Yao 1976) established the theoretical foundation for exact discrete sampling using discrete distribution generating trees. Their seminal result shows that any opti- mal sampling algorithm requires between (p) and (p)) + 2 bits per sample, where (p))
-p- (p:) is the Shannon entropy. While entropy-optimal, discrete distribution generating trees typically require exponential memory in the distribution precision. Lumbroso (2013) over- came this limitation for uniform and Bernoulli distributions with a linear memaryyemory implementation, but the approach does not generalize to arbitrary distributions. The generic interval algorithm (Hao)
and Hoshi 2006) achieves linear memory usage while consuming at most H()) +-3 bits per sample. However, implementations require expensive binary searches at each sampling step, limiting practi- cal efficiency (Devroye and Gravel 2020 Uyematsu and Li. 2003). Saad et al. (2020) presented the FLDR algorithm that combines entropy-optinee sampling with rejection sampling, achieving an up- per bound of (p) + bits per sample. improved this to (p) + bits with faster sampling speed for the ALDR algorithm, though at higher memory cost. Building on Marsaglia (1963), MMrsaglia jet al.) (2004) proposed compressed lookup tables for discrete sampling. However, their compres- sion scheme requires conditional branching and searches across multiple tables during sampling.
2

---

Published as a conference paper at ICLR 2026
reducing efficiency. In contrast, our approach uses single compressed table with direct indexing, eliminating conditional overhead.
Approximate methods Most samplers for discrete and continuous distributions used in practice are so-called approximate samplers (for introduction, see (Schwarz, 2011). These methods typ- ically rely on the assumptions of the real Random Access Machine (RAM) model (Shamos 1978] computations can be performed with arbitrarily precise real numbers), and the assumption of hav- ing infinitely precise uniform random generators (Devroye 1986), which cannot fully realized on digital computers. For comprchensive overview, [evroye (1986) presents the mathematical foundations of random sampling and details numerous approximate samplers built on the real RAM model. As noted by Draper and Saad (2025), implementations consequently suffer from multi- ple sources of approximation error and are often inefficient in their use of bits, since generating single uniform random variable typically already consumes 32 or 64 bits. widely employed general approximate sampler is the Alias method (Walker 1974), which preprocesses distributions into probability and alias arrays, enabling sampling via one uniform random variable and a single coin flip (see SSchwarz (201T) for detailed explanation). While being fast, it produces approximate samples and lacks controllable error bounds. Similarly, the Index method (Chen and Asau 1974) uses preprocessed index tables to guide inversion-based approximate sampling, but still requires expensive search operations.
In contrast, our proposed method does not rely the real RAM assumption or on access to arbi- trarly precise random samples from the unit interval. achieves exact sampling while remaining highly entropy-efficiene using close to the minimum number of bits required to represent the target distribution (see Figure (4).
3 APPROACH
Our approach is based on the idea of lookup tables, reusing precomputed results, while conserving memory requirements and memory accesses as detailed in this section. A schematic of the sampling pipeline is given in Figure la
Naive approach We will describe a method to generate random variates from any finite discrete distribution, represented by n probabilities Pi....,Pr, Pn [0, of the n outcomes Ti,..., In X. Ideally, we would construct lookup table containing duplicates of each outcome proportional to its probability:
occurrences of x; in table
table size
Pt-
Sampling would then reduce to uniformly selecting a random table index I ~ Uniform (1, (1......) N) and returning $ = Table[T], where N is the table size. See Figure 1b for an examplary "naive" lookup table.
Memory constraints In practice, memory constraints bound the table size N. limiting repre- sentable probabilities to multiples of 1/N. Approximating probabilities to precision b bits requires quantizing each p; to fi = round(p; 22), yielding frequencies f=(J1....; fn) and a table of size N = E. 2 (see the Appendix C for rounding schemes and error analysis). While approx- imation error decreases logarithmically with b, memory requirements grow exponentially, making high-precision sampling prohibitive. Our approach also handles continuous and infinite discrete dis- tributions through discretization techniques detailed in the Appendix, Section B The basis of our main approach lossless compression strategy for the lookup tables and the following sampling scheme.
Compression scheme To tackle the prohibitive memory requirements of lookup tables, we pro- pose to use the following compression scheme. Intuitively, the compressed lookup table can be viewed as a two-dimensional array consisting of r + 1 rows and 2 columns, with r, c E {o...... bb corresponds to frequency of 2" where row indices run from 1 to r. The r+11th row corresponds to the same frequency as the r-th row, namely 2 1. For exemplary compression, see Figure Tb This lossless compression scheme
satisfying +c = 2h N. Each row of the first
3

---

Published as a conference paper at ICLR 2026
mavve lookup Lable
compressed lookup table
corresponding
Eutesgy Souceel
x= b,
frequencies
Geometrical
Truncated
Uniform
4
Tnclex
Cohrmn Tnclex
p=
5. (16 16
a
8
&
b
b
b
Single Looleup
(=,7,5,3,
d
(a) Schematic of sampling.
(b) Example (compressed) lookup table.
Figure 1: a. Schematic of generating a single sample using our approach: i..d. Ber(0.5) bits are drawn from an entropy source to compute a row and column index, yielding in single lookup on the precomputed table. Illustration of the precomputation step: A naive and compressed lookup table for example distribution given by x- b, c, d) and p- 16' table (left table) contains each value according to its frequency f=(7,5, bits. The compressed lookup table (middle table) stores the same distribution when considering the geometric frequency scheme (right table). For example, the frequency of "a" is given by compressed lookup table + 2 7 and thus equals the frequency of "a" in the naive lookup table.
7 16 16 The naive lookup
3
at precision of
preserves the total frequencies
Σ 2'-1. 2" 11 -2"
N,
while drastically decreasing the size of the lookup table. Compressing naive lookup table with N 2r+c entries to a compressed lookup table with (r + 1) 2 entries (organized in r rows and 2 columns) yields compression ratio of 2" / 1).
In the example of Figure [b] the compression ratio would be p = 23 + = 2, which yields a compressed table half the size of the naive table. The compression ratio improves exponentially with r. up to a linear correction factor of r + 1, with the concrete values of r, and therefore of p. depending the frequencies f. Intuitively, better compression corresponds to increase in the number of rows (larger r) accompanied by an exponential decrease in the number of columns, re- sulting in "taller" and much "narrower" lookup table. This compression scheme always possible for lookup tables of size 2b_ To see that, note that the compressed and the naive lookup table coincide for the choice of r=0 and c=b.
Sampling step To generate sample S X' using a compressed lookup table, we generate two indices independently: a row index E f1.....r+1) and column index J fl..... 2º). We sample the index I according to truncated geometric distribution, and the column index J uni- formly:
P(I = = max(2 2-*) for ==...,,,,+t and P(J = = = 2 for 1,..,,
Therefore, sample table-index (I,J) (i.j) with probability 2- min(i.r) The column index can be efficiently sampled using any uniform sampler. The row index can also be sampled extremely efficient using the entropy optimal procedure detailed in Algorithm [ in lines 2-8. A sample is then generated by returning the value stored in the compressed lookup table at that index:
S compressedTablell.J
Preprocessing step Before sampling, must construct the compressed table. Conveniently, we do not have to construct the uncompressed lookup table, which could induce severe memory issues. We rather construct the compressed lookup table directly from the binary expansion of the frequencies f.. A value z; appears in row j if and only the j-th bit f(0) of f. is one. The frequencies can be adjusted to sum to exactly 2 by using a sum sum-preserving rounding scheme, making sampling procedure rejection-free. Although the total probability mass and relative ratios are preserved in the compressed lookup table, the number of active bits across the binary representations of the f, may differ, which results in rows of unequal width in the initial construction of the compressed lookup table. To improve the sampling speed, we ensure that all rows have uniform width as detailed in Algorithm Znd Figure
4

---

Published as a conference paper at ICLR 2026
Algorithm Sampling from compressed lookup tables
Require: number of samples K, compressed lookup table compressedTable size (r+1) x2 Ensure: array of samples S
1: for k k= to K do
2:
T+1
while + do // Sample row index geometrically:
4:
if DrandomBii( = then
5:
break end if
6:
7:
I+1+1 end while
8:
9:
+ Uniform(1,...... 2 Sample column index uniformly.
10: S[k] < compessedrable]..]] // Generate sample from the distribution.
11:
end for
12: return
distribution
binary expansion
initial compressed
rectified
Frq.
lookup table
compressed
x =
(a, b, 0)
(f1) = 1110
Frq. lookup table
(f2)2 = 0110
14 6 7
(fa)2 = 0111
321
321
321
92
(f = 0011
== (14,6,7,3,)
(f6)2 = 0010
Figure The initial and final compressed lookup table for an example distribution given by xa b, e) and p= 32 32 32: 35 In first step, the table filled according the binary expansion of the frequencies (left table). Then, the table is rectified by moving entries from higher to lower rows while doubling (right table). For example, the "a" in the top corresponding frequency of & (blue), is replaced by one "a" in the second row, which corresponds to frequency of 4, and 4 "a"'s in the bottom rows, which correspond row frequency of 2) is replaced by further two "a" in the bottom rows. The total frequency of each value is preserved, and the rows have equal length. In this case, 5, r and c 2.
frequency of 1, while the "a" in the third
EVALUATION
To demonstrate the advantage of our sampling method, we compared to state-of-the-art sampling methods in five experiments.
Evaluation Setup All measurements were taken standard laptop equipped with Intel i7- 1255U CPU and 16 GiB DDR4 memory running Ubuntu Linux
Modern CPUs provide hardware counters that monitor the current power and energy demand. On the x86 64 platform, Rumning Average and Power Limit (RAPL; David et al. 2010) counters provide resolution. RAPL is organized into different power domains, representing
energy readings different parts of the system. For this work, we focus on the CPU domains cores and package (pkg). The latter includes the former and additionally other parts of the CPU socket, such caches and the memory controller. There are several factors that make energy measurements noisy, apart from default hardware noise. They include background activities, battery charging, artificial noise against side-channel attacks for security reasons (Lipp et al.) 202I), etc. We limit these influences by dis- abling CPU security features, keeping the laptop charged, providing additional warm-up rounds, and measuring multiple iterations. Additionally, we set a constant CPU frequency and CPU core to get meaningful energy readings, as detailed in the Appendix, Section We evaluate all methods (both in Python and in C) on fixed set of synthetically generated distributions of sizes n [10*, 10"] drawn from exponential distributions with varying parameters to span a broad range of entropy val- ues, with zero probabilities removed. The bit precision is set to b 16 for [10', 10+). 5 20 for n E [10*, 108) and 23 for n E [10%, 10"]. Evaluations on further distributions are in the
Appendix, Section G
5

---

Published as a conference paper at ICLR 2026
cLUT
NumPy
JAX
PyTorch
10
Preprocessing time [s]
10
Compression ratio P
16
Sampling time [+]
20
10a
10
agnddras
10
10:
10
-4
10
100
10a
102
10a
10
10a
10
107
10a
10a
10
10
20
Number of outcomes
Entropy H(p)
Figure 3: Comparison of our cLUT approach with standard sampling methods from popular machine learning libraries (NumPy, JAX, PyTorch). Shown are (I) the average wall time (in seconds) to generate 102 samples from distributions of varying sizes n E [10', 10"], (2) the preprocessing time, and (3) the compression ratios p of the cLUT algorithm. Distributions are discretized Exponential distributions with varying parameters to cover broad range of entropies, with zero probabilites excluded. The plots are shown on a log-log scale. Each measurement was repeated ten times and averaged.
Table I: Average wall time (in seconds, mean + std) for generating 10" samples and the preprocess- ing step in Python. Evaluated in two subsets of the distributions from Figure split by size.
Outcomes:
E [10', 109)
[10 10")
Method
Sampling time (s)
Preprocessing time (s)
Sampling time (s)
Preprocessing time (s)
NumPy
0.6680 + 0.2650
0.0001 + 0.0001
9.6248 + 3,5823
0.0308 + 0.0202
PyTorch
0.6073 = 0.2436
0.0003 = 0.0006
3.3768 + 1.0615
0.1028 + 0.0655
JAX
0.3647 = 0.1277
0.2898 0.0894
0.7982 0.1815
0.6528 0.0948
cLUT
0.0374 = 0.0051
0.0006 = 0.0011
0.1016 0.0129
0.3925 + 0.2219
Sampling speed in Python We benchmarked our method against standard discrete sampling rou- tines from widely used Python machine learning libraries: RandomGeneraton
cho ce from NumPy, multinomian () from PyTorch, and random. choice () from JAX (Harris et al.)
2020 Paszke et al. 2019; Bradbury al., 2018). As shown in Figure S our method achieves 10-100x speedup across a wide range of distributions. The performance advantage is most pro- nounced for distributions with a large number of outcomes: Table reports 10x improvement for distributions with 10a to 10 entries, with the speedup growing to over 100x already for dis- tributions with 10t to 107 entries. This particularly relevant when targeting high-precision and high-diversity random variate generation: 16-bit data type already represent 65,536 distinct values, whereas 32-bit and 64-bit types can represent vastly more (over 10" and 10 respectively), making conventional sampling increasingly inefficient. Furthermore, plers in NumPy, py PyTorh, and JAX build on the Inversion method (Devroye) 2006) and produce distributions that only approximately similar to the desired distribution, whereas proposed method produces exactly the specified distribution.
should note that the sam-
For evaluations including graphics processing units the Appendix, Section F and Figure
Sampling speed compared to SOTA implementations in C We compare our cLUT sampler to the following state-of-the art sampling methods: the Alias method (Walker) 1974), ALDR, and FLDR (Draper and Saad 2025). All samplers are implemented in C, provides a lower execu- tion overhead compared to, c.g., Python. This allows for proper assessment of the actual costs the algorithm. To ensure comparability, apply the same degree of fair but not over-engineered opti-

---

Published as a conference paper at ICLR 2026
+
cLUT
Alias method
ALDR
FLDR
2a
30
24
25
Preprocessing time [s]
Sampling pkg energy [J]
Average consumed bits
Sampling time 1
2--24
2"
2a
20
2
2.25
15
2
11
10
2 2-
2'
2-21
theoretic minimun
2-27
10 10 10t 10
10 10 10a
102 10 10th 10
10 20
Number of outcomes
Number of outcomes
Number of outcomes
Entropy H())
Figure 4: Comparison of our cLUT approach with existing state-of-the-art sampling methods in C. Shown are (1) the wall time required for generating single sample (averaged over 102 repetitions) and (2) preprocessing (averaged over 10 repetitions), as well as (3) the cumulative energy demand of the CPU socket for generating 10" samples. Time and energy are shown on log-log scale. The fourth subfigure shows the average consumed bits sample from the entropy source.
Table 2: Average energy demand, wall time, and power draw of a single sampling operation in C. The power draw series computed by dividing the energy series by wall time. It averages over all CPU instructions of a sampling iteration. High variance in entropy and distribution size results in the high standard deviation here. Shown are distributions from Figure 4 split by size.
Outcomes:
[10%,100 10a)
[10", 10a)
Method
Energy (nJ)
Time (as)
Power (W)
Energy (n.))
Time (us)
Power (W)
ALDR
263.451 + 50.300
22.431 + 1,250
11,838 + 2.604
1223.520 + 194.457
102.792 12.066
12.168
2.800
Alias method
319.801 72.045
26.803 2.934
12.156 3.549
887 613 185.627
55.916 13.709
16.502 3.897
FLDR
290.223 1 47.274
21 268
+ 2,373
14.011 +: 3.770
1214.362 = 177 177.125
101.404 = 9.702
12.195 :: 2.753
1.689
4.091
mization across these methods. We avoid multi celti-tthradinn or (auto) vectorized code and use identical compiler flags. All methods use the identical entropy source.
For our experiment, we distinguish between the preprocessing phase (ten repetitions) and the actual sampling operation (ten million repetitions). The latter be performed quickly and repeatedly after the higher, one-time upfront cost. Figure/Ashows our results, indicating that our cLU' method samples consistently faster for all distributions than our competitors in terms of sampling time. Table 2 shows mean and standard deviation of the sampling time on two representative subsets of the distributions E [103, 104) and n E [10?, 108)).
Energy consumption compared to SOTA implementations in To demonstrate energy- saving potential of our approach, we compare the energy demand of all implementations. Due to space restrictions, Figure only shows the energy demand of the sampling operation across the entire RAPL package domain (CPU socket and memory controller), which is representative of the other measurements. Again, our cLUT approach works best across all sizes.
Although the energy demand roughly follows the same trend the required time, the scale is not linear. This is because time is not an accurate indicator of the energy required by complex real-life computing systems. Rather, energy is the integral of the dynamic power demand over time.
Our cLUT's single index- based memory lookup requires fewer switching transistors in the memory subsystem, compared e.g., ALDR with multiple memory accesses flattened search tree.

---

Published as a conference paper at ICLR 2026
cLUT
ALDR
Entropy
(H)
Time (C)
Energy (C)
Alias method
FLDR
10
20
Time (Python)
Break even point n
Memory [bytes]
109
10a
Memory [bytes]
10a
10t 10a
10º
10.
10:
100 102
10a 10a 10 10 10
10 10 10 10? 10
10a
10a
10
10?
10a
Number of outcomes n
Number of outcomes
Number of outcomes
Figure 5: Comparison of cLUT with state-of-the-art sampling methods in terms of memory usage and break-even analysis: (1) peak memory usage for all methods (including preprocessing), (2) memory usage of compressed cLUT table, and (3) break-even analysis against the Alias method. The break-even point is the minimum number of samples needed for cLUT to offset its preprocessing overhead relative to the Alias method (in terms of sampling time or energy consumption).
Memory usage and preprocessing overhead We measure peak memory usage for all approaches and perform break-even analysis for sampling time and energy consumption compared to the com- monly used Alias method. Peak memory usage refers to the maximum amount of memory utilized by program during execution. As shown in Figure 5 the cLUT approach consumes slightly more memory at peak times than other state-of-the lookup tables and therefore the memory usage after preprocessing relatively small, especially for low-entropy distributions due to high compression ratios (see Figure(5) middle Figure; and compare Figure 3 for compression ratios). A break-even analysis against the Alias method shows that this overhead is offiet after reasonable number of sampling iterations.
algorithms. However, the constructed compressed
As shown in Figure 4 the preprocessing phase (look-up table creation) scales log-linear with the distribution size across all investigated methods. Our cLUT method shows the highest time demand for the preprocessing phase and the Alias method the lowest one. Thus, our approach requires more sampling operations to offset its higher initial costs, but is then more time efficient, especially for larger distributions. As shown in Figure [ the break-even point n² for sampling time compared to the Alias method is approximately linear in the distribution size. For energy efficiency, it ranges from I to below 103, indicating that the energy efficiency gains of our algorithm outweigh the increased preprocessing overhead already for small sampling sizes, even for large distributions.
Bit efficiency compared to SOTA algorithms Sampling algorithms are commonly evaluated based on the average number of independent fair coin flips (i.e., i.i.d. Bernoulli(0.5) bits) required to generate a single sample. Generating a single sample with our cLUT method requires e random bits generate the column index J {l...., 29 (i.e., uniformly sampling one of the 2 entries in row, cmp. Line in Algorithm [] and between and r bits to generate the row index / E {l, + (emp. Lines 2-8 in Algorithm [ Since I follows a truncated geometric distribution, the expected number of random bits required to generate the row index / is Ei= i-2- - = Hence, the expected number of required random bits to produce single sample is b- (r-1),
(r-1),
Furthermore, 50% of the generated samples consume as few as - r + 1 random bits, as in these cases only single bit is needed generate the row index. Empirical evaluations indicate that our method is close to the information -heooreticcccc minimal cost of sampling (- (~E, P; lo., (Pt). see Knuth and Yao 1976)) and approaches the minimum for high-entropy distributions (see Figure
see
Typical values Discretizing (using the finite tail extension detailed in the Appendix, Section B a standard gaussian distribution to the values of the 16-bit floating point format at a precision of b 20 bits (removing values with probability less than 2 20 yields
20136 values with non- zero probability, covering 99.669 66% of the total probability mass. Applying cLUT yields a compressed table with 6, 14, and 11 4688 entries (229.38 kB, p = 9.14x smaller then the uncompressed
8

---

Published as a conference paper at ICLR 2026
Table Average energy consumption and wall time for TrueSkill with different sampling methods.
Method
mep (J)
rapl:cores (J)
rapl:pkg (J)
Sampling time (s)
NumPy's discrete sampler
201.05 + 2.45
91.19 + 1.71
116.31 + 199
1.65 + 0.01
NumPy's continuous sampler
160.26 +: 1.89
72.65 + 1.34
93.36 1.71
0.88 4 0.03
cLUT (ours)
132.69 + 1.13
60.82 0.72
77.99 = 0.91
0.46 + 0.01
table). Discretizing Gamma distribution with parameter k = 2 to the 16-bit format at a precision of b = 24 bits yields n = 11058 values with non-zero probability, covering 99.99% of the total probability mass. Applying cLUT yields compressed table with r 11, 13, and 98304 entries (196.61 kB, p = 170.67x x smaller then the uncompressed table). Values for other precisions and distributions are shown in Figure in the Appendix, Section B
4.1 SAMPLING OF UNIFORM FLOATING-POINTI
Besides the proposed cLUT method, our index-based sampling scheme is ideally suited for gen- erating uniformly distributed floating-point numbers over fixed intervals, such as the unit interval [0, 1]. Specifically, by considering their binary expansions, indices generated by our method as the exponent and mantissa of the floating-point representation, respectively. Using this approach, we achieve truly uniform sampling with maximal coverage of representable values. In contrast, classic approaches for generating random numbers in fixed in- tervals cover only small fraction of all representable numbers in the intervals and oftentimes fail statistical tests uniformity (see Appendix Kb.
interpret the and column
4.2 EXEMPLARY AAPLIIAAAPPPICAAIIICO APPLICATIONS
In addition to evaluating the algorithm, we aim to show the potential impact of our approach on real machine learning applications. To reduce overhead and avoid confounding factors, we select task in which sampling accounts for a significant share of total energy consumption. One example of such task sampling Bayesian posteriors with non-conjugate priors, and TrueSkill (Herbrich eet al. 2006) system serves an illustrative case.
The purpose of TrueSkill is to infer posterior skill distributions of players from match outcomes; this probabilistic machine learning systems currently in use large scale. Although the original algo- rithm is limited to closed-form solutions for Gaussian priors, we extend its applicability to arbitrary prior distributions through importance sampling scheme, detailed in the Appendix, Section [H] This extension enables more flexible modeling of assumptions about the skill distributions, allowing for non-conjugate priors.
First, we conduct experiments against a fair discrete competitor (RandomGenerates torr choi ce from NumPy). We then highlight the broader applicability of the approach by testing it against fast distribution-specife sampler for a Gaussian mixture [RandomGeneres ratton normal with mixture logic from NumPy), showing that our method is effective not only for discrete unparameterized dis- tributions but also for parametrized distributions that are (slightly) more complex than standard ones. We measure the end-to-end energy demand in the setup detailed in the Evaluation section, recording core and pkg RAPL domains. As an additional ground truth and better electricity bill proxy, we include the laptop's wall socket energy consumption using a Microchip MCP39F51 IN device. As result, our method reduces the total execution time of TrueSkill by 72% and decreases the total energy consumption by 34% compared to the discrete sampler. Even against the specialized mixture sampler, cLUT demonstrates competitive performance with 48% reduction in sampling time and 17% decrease in overall energy consumption, as shown in Table 4 At the same time, cLUT outputs near identical posterior distribution as the two NumPy-based methods (see the Appendix HH.
Additionally, an exemplary application of cLUT to the training and inference of a diffusion model is given in the Appendix, Section

---

Published as a conference paper at ICLR 2026
5 CONCLUSION
We present cLUT, a new fast and energy-efficient sampling method for sampling from arbitrary distributions, based operations with compressed lookup tables. Time sample distribution speeds up 10-100x compared to commonly used machine learning Python libraries. It saves up to 50% in energy compared to state-of-the art methods. We further showcase the value of our sampler in real-world applications by reducing up to 34% energy consumption and 72% execution time in the TrueSkill example.
We provide fairly optimized, robust, and understandable reference implementation of our algo- rithm C, as well as wrapper library that can be used with other programming languages, such as Python. We have not vectorized or parallelized our implementation to improve understandability and facilitate comparison with other methods. However, our sampling method only requires a sin- gle index-based memory lookup and some arithmetic and bit-shift operations. This makes it better suited than competing approaches for single instruction, multiple data devices (Flynn 1972). such modern vector and graphics processing units, given compatible streaming source of entropy.
ACKNOWLEDGMENTS
This research has been conducted through the funding of research scholarship by the Hasso Plattnrr Foundation and was partially funded by the German Research Foundation (DFG) - 502228341 ("Memento").
10

---

Published as a conference paper at ICLR 2026
REFERENCES
I. A. Barroso and U. Hölzle. The case for energy-proportional computing. Computer, 40(1))333333 2007. doi: 10.1 10.1009//.200 .433.
J. Bradbury, R. Frostig, P. Hawkins, M. Johnson, C. Leary, D. Maclaurin, G. Necula, A. Paszke, VanderPlas, Wanderman-Milnee and Q. Zhang. JAX: composable transformations of Python+NumPy programs, 2018. URL http: thub. com/ jax ml ml/jax
H.-C Chen and Asau. On Generating Random Variates from an Empirical Distribution. A E Transactions, 662):163-166, June 1974. ISSN 0569-5554, doi: 10. 101108000509555740774499999
BtRLhttp://warr httt:::/www.aaa.ff..... www.:aaaddoooooo
com doi awa///bb///i/ http:///.....0000.00000665555113
T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A Simple Framework for Contrastive Learn ing of Visual Representations, July 2020. URL http:: wttp://wwwrg//ab//2200555555 arXiv:2002.05709 [es].
H. David, E. Gorbatov, U. R. Hanebutte, R. Khanna, and C. Le. Rapl: memory power estimation and capping. In Proceedings of the 16th ACM/IEEE International Symposium on Low Power Electronics and Design, ISLPED '10, page 189-194, New York, NY, USA, 2010. Association for Computing Machinery. ISBN 9764450301466. doi: 10.1 10.1145//840855.184488
L. Devroye. Non-Uniionnn Uniffrm Random Variate Generation. Springer New York, New York, NY, 1986. doi: 11177/978---413-880 URL http:
ISBN 978-1-4613-864522 978 1--11--663--4333 8643-8
7/1ink www.spriiggg iigeringgr..oo com 10. 97 011000797781-44---888888-
Devroye. Nonuniform random variate generation. Handbooks operations research and man- agement science, 13:83-121, 2006.
Devroye and C. Gravel. Random variate generation using only finitely many unbiased, indepen- dently and identically distributed random bits, Nov. 2020. URL http::tpaaxxxi.oog///// 15C2. 02539 ar arXiv:1502.0223 [cs].
T. L. Draper and F. A. Saad. Efficient rejection sampling in the entropy-optimal range, Apr. 2025. URL
abs/ 04267 arXiv:2504.0426 [cs].
M. J. Flynn. Some computer organizations and their effecttivnness. IEEE Transactions Comput- ers, C-21 960, 1972. doi: 10. (1110//...97...00000
V. Gadepally. Ai has high data center energy 2025.
but there solutions, mit htt.://aa..nit..cddddeeeeeeeeeee has high data center enwery-eeryyyym costs there are solutions
URL
T. S. Hao and M. Hoshi. Interval algorithm for random number generation. IEEE Trans. Inf. Theor, 43(2):599-611, Sept. 2006. ISSN 0018-9448. doi: 10.1109/18.556116 URL https:://doo
org/10.1109/11 116111
556116
C. Harris, K. Millman, S. J. van der Walt, R. Gommers, Virtanen, D. Cournapeau, Wieser, J. Taylor, S. Berg, N. J. Smith, R. Kern, M. Picus, S. Hoyer, M. H. van Kerkwijk, M. Brett, A. Haldane, F. del Río, M. Wiebe, Peterson, P. Gérard-Marchant, K. Sheppard, T. Reddy, W. Weckesser, H. Abbasi, C. Gohlke, and T. E. Oliphant. Array programming with NumPy. URL https://
Nature, 585(7825):357-362 Sept. 2020. doi: 10. 10.10388641158-002-26666 doi Roi.org/ 10 1038 1ttp://......1//1111---0-------0 220-269-22222
R. Herbrich, T. Minka, and T. Graepel. Trueskill bayesian skill rating system. Advances in neural information processing systems, 19, 2006.
Ho, A. Jain, and Abbeel. Denoising diffusion probabilistic models. Advances in neural infor- mation processing systems,
2020a.
J. Ho, A. Jain, and P. Abbeel. Denoising Diffusion Probabilistic Models, Dec. 2020b. URL http: //arxiv.org/aaaa hwwps/wwwwrr//bb////000e// 11239 arXiv:2006.1 1239 [cs].
11

---

Published as a conference paper at ICLR 2026
M. Horowitz. 1.1 computing's energy problem (and what can do about it). In 2014 IEEE international solid-state circuits conference digest of technical papers (ISSCC), pages 10-14. IEEE, 2014.
International Energy Agency. Energy demand from ai, 2025. URL https: iea. org/ reports/enerqy and ai/ het/enerry-ddaaaane from-ar ai
D. P. Kingma and M. Welling, Auto-Encoding Variational Bayes, Dec. 2022. arxiv. org/
URL http://
6114 arXiv:1312.6114 [stat].
D. Knuth and A. Yao. Algorithms and complexity: New directions and recent results. Academic Press, 1976. Section: The complexity of nonuniform random number generation.
E. Le Sueur and G. Heiser. Dynamic voltage and frequeney scaling: the laws of diminishing returns. In Proceedings of the 2010 International Conference on Power Aware Computing and Systems, HotPower' 10, page 1-8, USA, 2010. USENIX Association.
S.-g. Lee, H. Kim, C. Shin, X. Tan, C. Liu, Q. Meng, T. Qin, W. Chen, S. Yoon, and T.-Y. Liu. Priorgrad: Improving conditional denoising diffusion models with data-dependent adaptive prior. arXiv preprint arXiv:2106.06440 2021.
M. Lipp, Kogler, D. Oswald, M. Schwarz, C. Easdon, C. Canella, and D. Gruss. PLATYPUS: Software-based Power Side-Channel Attacks on x86. In 2021 IEEE Symposium Security and Privacy (SP). IEEE, 2021.
J. Lumbroso. Optimal Discrete Uniform Generation from Coin Flips, and Applications, Apr. 2013. URL hRttp:////xxix org/ /bss/134.... 1916, uXXvv1134.1911 [cs].
G. Marsaglia. Generating discrete random variables in computer. Communications of the ACM, 6
(1):37-38, Jan. 1963, ISSN 0001-0782, 1557-7317. doi: (0.1145536619933362228 URL http::
7/dl acm. /ttg//////...ooo//////////g wtt.o//......1111..11111111 1141/1661111.... 366228
G. Marsaglia, W. W. Tsang, and J. Wang. Fast generation of discrete random variables. Journal of Statistical Software, 11:1-11, 2004.
A. J. Martin, M. Nyström, and P. I. Pénzes. Er2: A metric for time and energy efficiency of compu- tation. In Power aware computing, pages 293-315. Springer, 2002.
E. Nachmani, R. S. Roman, and L. Wolf. Non gaussian denoising diffusion models. arXiv preprint arX1v:2/06.07582, 2021.
A. Paszke, S. Gross, Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Kopf, E. Yang, Z. Vito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, Bai, and S. Chintala. PyTorch: An Imperative Style, High-Performance Deep Learning Library. In Advances in Neural Information Processing Systems, volume 32. Cur- ran Associates, Inc., 2019. URL 288
wwwrips.eccpppoc. wttpppss.ccppppppppeeeeeeeeeeee .html
2aper/2011
F. Saad, C. Freer, M. Rinard, and V. Mansinghka. The Fast Loaded Dice Roller: A Near-Optimal Exact Sampler for Discrete Probability Distributions. In Proceedings of the Twenty Third Interna- tional Conference Artificial Intelligence and Statisties, pages
PMLR, June 2020. ISSN: 2640-3498.
URL httpttts////proeeeedd ngs. m1 www.ppesssvv/////p http:/vvvv//aaaa .htmm
K. Schwarz. Darts, Dice, and Coins, Dec. 2011. / darts-dice-coins/
www. www.s///wwww.kithhcchwaa.......
M. I. Shamos. Computational Geometry. Yale University, 1978. Ph.D. dissertation.
F. Sommer, J. Robnik, G. Nozadze, U. Seljak, and D. Rügamer. Microcanonical langevin ensembles:
Advancing the sampling of bayesian neural networks. arXiv preprint arXiv:2502.06333, 2025.
T. Uyematsu and Y. Li. Two algorithms for random number generation implemented by using arith- metic of limited precision. IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences, F886A:254-22511. Oct. 2003.
12

---

Published as a conference paper at ICLR 2026
A. J. Walker. New fast method for generating discrete random numbers with arbitrary frequency distributions. Electronics Letters, 10(8):127-128, 1974.
P. Wiesner, R. Khalili, D. Grinwald, P. Agrawal, L. Thamsen, and O. Kao. Fedzero: Leveraging renewable excess energy in federated learning. arXiv preprint arXiv:2305.15092, 2023. URL
ittps::/aaxiin org/ wtg/abs////eooooooooo.../soaorar 2305.13320000 15092
Z. Yang, L. Meng. J.-W. Chung, and M. Chowdhury. Chasing low-carbon electricity for practical and sustainable dnn training. arXiv preprint arXiv:2303.00 02500, 2023. htRlptt:s://axxi
org brg/aba/20 2303. 02508
13

---

Published as a conference paper at ICLR 2026
A
NOTATION
Table 4: Notation.
Symbol
Description
b
Precision of frequencies in bits (c.g., minimal probability is 2- Number of columns in the compressed lookup table
2
vector of frequencies f (fi..... fn) E Noo corresponding to p and b
Row index in cLUT sampling
Column index in cLUT sampling
N
Size of naive lookup table
Distribution size (number of outcomes)
P
vector of probabilitiess p (pi..... .P.) E [o, 1]" specifying the target distribution Shannon entropy of p specifying the target distribution
(P))
r r+1
Number of rows in the compressed lookup table
Compression ratio (size of compressed lookup table divided by size of naive table)
X
Domain of sampled values, e.g. the set of representable floating point numbers A vector of values (#i Fn) X specifying the target distribution
14

---

Published as a conference paper at ICLR 2026
B DETAILS ON NON-FINITE DISTRIBUTIONS
Many distributions relevant to machine learning belong to the class of continuous, real-valued, uni- variate distributions, with the Gaussian distribution as a prominent example. These distributions discretized in a computational setting, as hardware can only represent finite set of values.
natural discretization proceeds follows. Let distribution on R be specified via its cumula- tive density function F. To discretize it on finite support A' C R ((X' < oo), e.g., the set of representable numbers the IEEE 754 16-bit floating-point format, we define the probability mass function X > [0, 1] of the discretized distribution by
p(a) = 1 [
Ve E Ex
2
2
where 24 = min E X : y X y < 2) is the next number to the left.
J} is the next number to the right
X, and x- == max E
Special care is required for the extrema of X. Let z= = max A' and xiin == min X. The next numbers beyond these limits can be defined in ways, depending on how you would like to attribute the probability mass of the tails:
1. Finite tail extension:
max
x
max
max
max
2 min
J.
min +
2
min
which requires a normalization constant c = discretized probability mass function sums one.
F(x:T.x) + F(x:min) to ensure that the
2. Infinite tail extension: -= +oc and -- -0, in which case 1 suffices.
Discrete distributions with infinite support, such as the Poisson distribution over N also require truncation be represented in finite precision. common approach is apply a cutoff.
15

---

Published as a conference paper at ICLR 2026
10
Normal(0,5)
Gamma(k-2)-.. Exponential(A (A-1)
30000
1.9000..253 925 9500 ....9.70000 1.0000
Number of outcomes
Probability mass
Memory KiloDytes]
300
20000
200
10000
100
16
20
16
20
24
20
24
14
10
150
Compression ratio
8
100
6
50
16
20
24
16
20
24
20
24
Precision b
Figure 6: Typical values for classic continuous distributions when discretized to the 16-bit floating
point range X' with precision of b E [15.... 24), described in section 3 Shown are (1) the number of outcomes n, i.e., the number of values with non-zero probability, and (2) the covered probability mass (sum of all probabilities before normalizing) after rounding to precision b. (3) Memory consumption, (4) row parameter r, (5) column parameter c, and (6) achieved compression ratio p of the compressed lookup table.
16

---

Published as a conference paper at ICLR 2026
C DETAILS ON APPROXIMATED DISTRIBUTIONS
Since memory constrains impose a boundary on the size of any lookup table, a lookup table might suffer from the inability represent certain probabilities, such as very small or irrational probabilities, e.g. Pt 11/2. In these cases fill the table according the frequencies
Jt = round(p: 2*) E N20, i (L,
where round(.) is an arbitrary sum nun-preerrving rounding scheme. The approximation error a distribution stored in a lookup table with probabilities f:/2" directly depends on the precision b, upper bound on the KL. divergence can be expressed as a function of minigiga Ji (see Theorem [
Theorem (KL--Dvvergence of approximated distribution). The KL-Divergence between distri- bution on x=(x) ... .nn) given by the associated probabilities p= Pr)) and the distribution approximated to a precision of b E Ny bits given by the frequencies : Sn) ) is bounded by
1
(p f) $ log
2k
where k minggin ft.
Proof. Write
Pt = fo + with 6, [-2 1-2-b-1,5 20-1,2-6-1. Then, the KL-Divergence is given by
DKL(p) |1 f)
Pi Σ pt log
.2
f: + 6;
Pi log
Si 2-b
64 -2h
pi log
1+
ft
2 2-b-1 2
Σ (=1
p: log
+
min; fi
log
1
Σ Pe
min; fi
i=1
=log
[1+
-
2x/
where x minigign fi. In the third step, used that 6, < 2-b-1 and fs min; fo for all
b-1
Note that minisis ft minisisa round(p: 2³) and therefore DRL. Ollog( + +))) Clearly, DKL + 0 for b + oc. However, while approximation error decreases logarithmically with precision b, the lookup table size required to store all values with their respective frequencies f-(f1.... fw) grows exponentially in b:
N = Σ fc 2b
17

---

Published as a conference paper at ICLR 2026
D PREPROCESSING DETAILS
pseudo code of the cLUT preprocessing algorithm that constructs the compressed lookup table is shown in Algorithm Algorithm calls the function distributed in line 4, which detailed in pseudo code in Algorithm
Algorithm Constructing a compressed lookup table
Require: probability distribution given by (I1, (2,, Fn) and f = (f1, f2, .n) No0 Ensure: compressed lookup table compressedTable of size (r 1) 2 Compute optimal r and
1: < log2 (Ei= Si)
2: r < max E
Ve E .o....,bbp b}} [0, EE f(0 20 1
3: c b-
Compute counts per row for each value:
4: + distribus distribute(f, r)
Fill compressed lookup table:
5: compressedTable +
6: for = to r+-1--6 do
7: for j = 1 to n do
to Dソ: do 8: for compresseddable..o compreeseedrbbleappenee)) a.apeedd(z))
9: end for
11: end for
12:
end for
13: return compressediaable
Algorithm Distribute counts across bit levels with distribute(
Require: frequencies = (f1, fa. E No E Noo- N
Ensure: bit levels D E N
Expand counts into bit-level representation
1: for = 1 to do
2: for j 1o do
Dij - (() 4: end for
3:
5: end for
Redistribute bits above level 6: for k = b downto r do
7: for 1 to do
8: D + D + 2 - Dak
9: end for
10:
end for
Adjust lower levels if cumulative sum exceeds 2
11: for k = downto 1 do
12:
a a+0 0
13:
for i
1 to to do
14:
x- a a +Dik
if a > 2 then
16:
- a - 2
Di +- D - 8
18: D 1) + Di(k-1) + 2-8
end if
20:
end for
end for
22:
return (Dij)sr41
18

---

Published as a conference paper at ICLR 2026
E IMPLEMENTATION DETAILS
We implemented the preprocessing and sampling methods in C and reused the computed data struc- tures Python. To do so, we created foreign function library that conveniently interfaces between and other languages. This library is used in our evaluation.
Like the reference implementation of ALDR and FLDR (Draper and Saad 2025), we used bit op- erations, compiler intrinsics and linearized arrays where possible to ensure fast computation. We extended the existing SOTA implementations to also work with 64-bit input values make them comparable with our test distributions.
Our implementation, wrapper library and changes to existing SOTA implementations are publicly available on GitHub under (omitted for blind review).
19

---

Published as a conference paper at ICLR 2026
F JAX INTEGRATION AND GPU EVALUATION
To demonstrate the integratability of cLUT as well as potential performance gains from SIMD im- plementations, we have integrated our cLUT approach into the JAX library, as shown in Listing [ and compared with the default sampling method from JAX, see Figure 7 This experiment was run on a single A100 GPU, using JAXs internal GPU mechanisms.
Listing I: Integration of cLUT into the JAX library.
jaax__re random. py
From jax. import numpy as jnp from jac src import prng
def choice (key: Arraylike, a: int Arraylike, shape: Shape = (),
replace: bool True, p: RealArray None Nene,
10
11
---- CHANGES
12
b = -1,
-1,
END CHANGES
15
axis: int 0,
16
mode: str | None - None) -> Array:
17
if replace:
19
CHANGES
20
return ccoccce (arr, key, c, b, shape, dtype)
21
END OF CHANGES
else:
24
25
CHANGES
26
@partial (jax. jit, static_argnamest
'shape', ddtype'] ))
def _choice (arr, key, e, D, shape, dtype):
28
- prng. C) mask rawdambnimttttt (key, b, shape)
29
30
return
(clz (B | mask) << c) (B & mask), 0)
END OF CHANGES
JAX with cLUT
JAX (default)
GPU sampling time [s)
10
10*
10
10a
Number outcomes
Figure 7: Comparison of our cLUT approach integrated into the JAX library with the default sam- pling method from JAX on GPU, Shown is the average wall time (in seconds) to generate 107 samples from distributions of varying sizes n E [10', 10 Distributions were extracted from ex- ponential distributions with varying parameters (and shuffled) to cover a broad range of entropies, using variable precisions was repeated ten times and averaged.
30). The plots are shown a log-log scale. Each measurement
20

---

Published as a conference paper at ICLR 2026
G
ADDITIONAL EVALUATIONS
cLUT NumPy
JAX
PyTorch
10
10
Preprocessing time [s]
Compression ratio p
M
10a
10-3
Sampling time
mm
100
10 10-2
102
m
08
10
10-1
4000
29999
440
40-4
4000000
40:00
00000
0
10-4
100
10a
10
106
10
10a
10
10
Number of outcomes n
Entropy H(p)
Figure 8: Comparison of our cLUT approach with standard sampling methods from popular machine learning libraries (NumPy, JAX, PyTorch) Similar to Figure but evaluated on sparse distributions. Shown (1) the average wall time (in seconds) to generate 10" samples from distributions of varying sizes n E [10', 10"], (2) the preprocessing time, and (3) the compression ratios of the cLUT algorithm. Distributions were sampled from Dirichlet priors with varying parameters cover a broad range of entropies, using fixed precision of = 16. The plots are shown on a log-log scale. Each measurement was repeated five times and averaged.
Table 5: Average wall time (in seconds, mean + std) for generating 10" samples and the preprocess- ing step. Evaluated in subsets of the distributions from Figure S split by size.
Outcomes:
E [10*, 100]
110 10"]
Method
Sampling time (s)
Preprocessing time (s)
Sampling time (s)
Preprocessing time (s)
NumPy
0.847 + 0.288
0.000 + 0.000
7.230 + 4.138
0.020 + 0.012
PyTorc
0.720 + 0.253
0.001 + 0.001
2.400 1.138
0.070 1 0.039
JAX
0.407 + 0.132
0.335 0.087
0.616 0.250
0.572 0.105
cLUT (ours)
0.095 + 0.025
0.001 +: 0.001
0.080 0.022
0.177 1 0.090
Table 6: Average energy demand, wall time, and power draw of single sampling operation. The
power draw series is computed by dividing the energy series by wall time. It averages over all CPU instructions of sampling iteration. High variance entropy and distribution size results in the high standard deviation here. Shown are distributions from Figure split by size.
Outcomes:
[10)
110 10*]
Method
Energy (nJ)
Time (ns)
Power
Energy (nJ)
Time
Power (W)
ALDR
240.65 73.91
18.83 4.75
13.21 + 4.28
225.38
53.64
19.56
4.56
12.29 4.61
FLDR
221.25 62.66
20.08
4.99
11.45 + 3.75
204.54 + 47.07
20.83
4.14
10:24 + 3.56
Alias
180.58 73.82
17.94
7.82
10.21 = 0.87
315.04
= 93.36
33.89
= 9.94
9.32 +: 0.48
cLUT (ours)
144.09 18.34
14.15 1.58
10.22 + 1.06
128.23
17.05
13.41
1.75
9.60 + 0.94
21

---

Published as a conference paper at ICLR 2026
+
cLUT
FLDR
ALDR
Alias method
2 24
2
2
25
Sampling pkg energy []]
Average consumed bits
2
Sampling time [8]
2 2-25
Preprocessing time
20
2
2-
15
2-1
10
2
2 2-1
2
2
theoretic
minimum
2 27
10
10 10a
10
10
10a
104
10
10a
0
10
Number of outcomes n
Number outcomes n
Number outcomes
Entropy H(P)
Figure 9: Comparison of our cLUT approach with existing state-of-the-art sampling methods. Sim- ilar to Figure 4] but evaluated on sparse distributions described in Figure Shown are (1) the wall time required for generating single sample (averaged over 10th repetitions) and (2) preprocessing (averaged over 10 repetitions), as well as (3) the cumulative energy demand of the CPU socket for generating 106 samples. Time and energy shown log-log scale. The fourth subfigure shows the average consumed bits per sample from the entropy source.
cLUT
ALDR
Entropy (II)
Time (C)
Energy (C)
= FLDR
Alias method
5
10
15
Time (Python)
10
Break even point n
Memory [bytes]
1
Memory [bytes]
10
10
104
10: 10:
10s
10a
1
108
108
10
106
10
10a
105 Number of outcomes n
108
Number of outcomes
Number of outcomes
Figure 10: Comparison of cLUT with state-of-the-art sampling methods in terms of memory usage and break-even analysis. Similar to Figure 5 but evaluated on sparse distributions described in Figure 8 (1) peak memory usage for all methods (including preprocessing), (2) memory usage of compressed cLUT table, and (3) break-even analysis against the Alias method. The break-even point n" is the minimum number of samples needed for cLUT to offset its preprocessing overhead relative the Alias method (in terms of sampling time or energy consumption).
H DETAILS ON TRUESKILL
Our TrueSkill extension uses importance sampling as follows: (1) independently sample skills 8; and performances y: from their respective priors, (2) compute importance weights the product of prior densities and match likelihood, and (3) use these weights to estimate posterior distributions. Independent sampling of correlated variables enables parallelization while maintaining correctness through importance weighting (Algorithm 4 We discretize the continuous bimodal prior over the range |- 10, 10] with resolution 10 and construct cLUT tables with b = 32 bit precision.
To evaluate the precision of the posterior distribution sampled by cLUT, we ran the TrueSkill algo- rithm 50 times using both the NumPy-based continuous sampler and the cLU sampler. Considering
22

---

Published as a conference paper at ICLR 2026
Algorithm 4 TrueSkill with importance sampling for two players
Require: prior skills distributions Ti (01) and T2((2), performance standard deviation B, match
outcome data
Ensure: posterior skills distributions m (0: R2) and (t)
1: for = to do
2:
7T2 (02) 3: y1 - (L,, 3), 1/2 + (1, 5)
$1 i (01).
Compute match outcome:
4:
r == In 222
Compute importance sampling weights:
5:
Pr. |0 (81), ), W2 Pmz 12 (82)
6:
w/ ()( (11), = .3( (12)
7:
w = II;I1 wi
Write down the results to arrays S1, S2, W:
8:
1 81, S2 82, W[i
9: end for
> Assign new posterior distribution as probability mass function:
10: (R) = [(51 [.. W())
11: (t) [S2 W 1) 1=
12: return m1 (1] 22
0g R)
that these two samples operate on different domains, we cannot employ test that compare density functions. For this reason, we evaluate sampled results by comparing first and second moments. For each iteration, we computed the mean and variance of player's 's skill posterior distribution. We then applied t-test to assess statistically significant differences in means and variances between the two samplers, obtaining p-val p-values greater than 0.2 in both cases, meaning that the moments sampled distributions do not have meaningful differences.
23

---

Published as a conference paper at ICLR 2026
I APPLICATION TO DIFFUSION MODELS
To demonstrate cLUT's impact in a core ML problem, we apply cLUT to a small-scale generative model. We train and validate toy diffusion model Ho et al. (2020a) designed to learn noise distribution from corrupted data. In our experiments, we generate the training data from a bimodal distribution (green line the Figure [T] and introduce corruption through another bimodal distri- bution. While the original algorithm assumes training and inference with Gaussian noise, previous work has shown that reducing the difference between the data and noise distributions can improve the precision of model Lee et al. (2021). Additionally, using Gaussian mixture can be beneficial replacement for certain tasks Nachmani et al. (202T). Our additional experiments are consistent with these findings: when training bimodal data, using Gaussian noise results in substantially larger Wasserstein distance between generated samples and the training distribution (greater than 1), while using bimodal noise reduces this distance to below 0.07.
Sampling is employed to simulate noise during both training and inference. We incorporate cLUT in both stages and compare its performance and energy consumption against the default sampling in JAX, as JAX was the most efficient library in our main evaluation. For the CPU evaluation, we use the same hardware setup as described before. We define shallow neural network with two linear layers and train on small batches of 8 samples for 3 x 10 steps. For the inference stage, we run the trained model for 10a iterations with the same batch size. To sample noise with the cLUT algorithm, we construct table with fixed precision of = 8. This preprocessing cost is included in the evaluation of the overall application's 's time and energy consumption.
Table shows that incorporating cLUT can save energy by 37% in the training stage and by 65% in the inference stage compared the default sampler of JAX. Additionally, to validate the quality of generated samples, we compare the output of the inference stages using the two different sampling algorithms, utilizing model trained with JAX's default sampler. As shown in Figure [T] the two samplers return nearly identical distributions for the generated data, with Wasserstein distance from training data to samples of 0.069 for JAX's default and 0.054 for cLUT, respectively.
Table 7: Comparison our cLUT approach with JAX incorporated into training and inference processes of denoising diffusion model.
Training
Inference
Method
rapl:cores (J)
rapl:pkg (J)
Time (6)
rapl:cores (J)
rapl:pkg (J)
Time (s)
JAX
3811.42 + 102.38
4702.91 + 86.61
265.77 + 5,29
331 13 3.67
403.29 + 6.53
19.89 + 0.22
cLUT
2392.14
2962.17 17 102.96
172.62 a: 5.11
116.11 1.97
143.08
3.06
7.28 0.08
Reduction with cLUTT
37.2%
37.0%
35.0%
65.0%
64.5%
63.4%
0.75
Geseated single (EUT))
Density function
Geowrated coeple (MAX)
Trabiing
0.50
0.25
0.00
Value
Figure 11: Generated data by the denoising diffusion model with cLUT and JAX sampling algo- rithms and comparison to the target data.
24

---

Published as a conference paper at ICLR 2026
J DETAILS ON ENERGY EFFICIENCY
is crucial to understand different metrics and their relation to assess the efficiency of modern (electrical) computing systems and design experiments. While power the rate at which electricity is consumed at a given point in time, energy is the amount of electricity required to perform an operation (power's integral over time). Electric energy translates to battery life, electricity bills or emitted carbon dioxide, making it the most reasonable metric to optimize for when seeking energy efficiency.
An exception would be if the computer system has actively changing clock frequencies. Apart from the number of active switching transistors, the CPU's clocking frequency and supply voltage play into the dynamic power demand at a given point in time (Le Sueur and Heiser (010). In this case, the energy-de snergy-delay-squaree product (Martin et al. 2002) would be a more suitable metric, combining execution time and energy demand.
Even at fixed clock rates, switching between CPU architectures can significantly alter power demand but not necessarily energy demand. A low-power device (a micro-controller core) can run for a longer time than a more power-intense one, resulting in comparable energy integrals-or not, depending
efficiency CPU
the static power demand and thus energy proportionality of the system (Barroso and Hölzle, 2007). For a fixed problem size, the latter device can switch to idle mode after completion or process more elements for a given unit of energy. Consequently, obtain more representative measurements, we fixed the CPU frequency and micro-architecture (cores) in our experiments. As our partieular Intel Hybrid CPU architecture comprises of larger performance cores and limited efficiency cores, we opted for the P-cores for consistent measurements.
There is direct connection between the memory access behavior of modern computer systems and their electricity consumption (Horowitz) 2014). Memory subsystems and CPU caches have long been overlooked comparison to computational cores but constitute a large portion of active transistors in today's 's chip designs, leading to higher dynamic power demands. This means that, for general-purpose computers, algorithms that trade computation for memory lookups may have slightly worse energy efficiency than plain recomputation. This effect is more pronounced with multiple, nested lookups (also known as pointer chasing) because it involves more active transistors, which increases power demand. It also breaks CPU cache locality and access prediction, resulting in prolonged CPU stalls (increased time demand) and thus non-linear increase in energy demand. This motivates idea create compression strategy for lookup table that preserves all the statistical properties sampling with simple lookup tables but reduces energy consumption.
25

---

Published as a conference paper at ICLR 2026
K DETAILS ON SAMPLING OF UNIFORM FLOATING-POINTS
In the IEEE 754 floating- paint format, numbers are organized into dyadic intervals of exponentially increasing size, each containing fixed number of equally spaced values. This structure makes our index-based sampling scheme ideally suited for generating uniformly distributed floating-point numbers over fixed intervals, such as the unit interval [0, 1]. Specifically, by considering their binary expansions, we can interpret the row and column indices generated by our method as the exponent and mantissa of the floating point representation, respectively. Using this approach, we achieve truly uniform sampling with maximal coverage of representable values.
In contrast, the classic approach of generating uniformly random mantissa bits obtain float in (1, and then subtracting 1 covers only a small fraction of all representable numbers, approxi- mately 13%. PyTorch's common method for generating random variates uniformly on the interval [0, is torch. rand (). When generating values directly in 16-bit foating-point format, this method covers only 13.3% of all representable values [0, 1]. A Pearson's x test for uniformity with p 10 10 Alternatively, generating values 32-bit floating-poing format and converting them to 16-bit representation results in 100% coverage of 16-bit floating-point values in the unit interval. However, this approach also fails the Pearson's x² test, with x² = 22,422 425, 2924 and < 10-10
fails significantly, yielding x2 1,277,749
26


Reviews:
[{"review_id": "rfoNuFEoIq", "reviewer": "Reviewer_byEu", "summary": "The paper introduces cLUT (compressed Lookup Tables), a method for exact, fast, and\nenergy-efficient random variate generation from arbitrary discrete distributions. The\nkey idea is to quantize the target distribution into integer frequencies, represent\nthose frequencies in binary, and compress the resulting lookup table by aligning entries\nalong bit-planes that correspond to powers of two. Sampling then reduces to drawing a\nrow index from a truncated geometric distribution and a column index uniformly from a\nfixed-width table. This produces exact samples using only bit-level randomness and a\nsingle memory access per draw.  \nThe authors benchmark cLUT against classical exact samplers and demonstrate superior\nperformance on large discrete distributions in both speed and energy efficiency. They\nfurther validate the method in an applied setting showing\nthat replacing NumPy’s RNG with cLUT yields equivalent posterior results at\nsubstantially lower runtime and energy cost. Overall, the paper proposes an elegant\nunification of algorithmic simplicity, theoretical exactness, and practical efficiency\nfor one of the oldest primitives in probabilistic computation.", "questions": "1. **Construction for general distributions.**  \n   The cLUT method requires a discretized finite support to construct its compressed\n   lookup tables. Could the authors clarify how this construction would proceed for\n   *continuous or parameterized* distributions (e.g., those in `torch.distributions` or\n   `jax.random`)?  \n   In particular:  \n   - How are truncation bounds and binning strategies chosen for unbounded or\n     heavy-tailed distributions?  \n   - How is quantization precision $b$ selected in practice to balance fidelity and\n     memory footprint?  \n   - Could this preprocessing be automated so that cLUT can serve as a backend for\n     standard probabilistic libraries?\n\n2. **Vectorization and hardware integration.**  \n   The reported benchmarks compare cLUT to scalar or lightly vectorized C baselines.\n   Many ML frameworks already implement heavily vectorized sampling kernels.  \n   - Can the authors comment on how cLUT would integrate into such environments, would\n     the same speedups hold once both systems are equally vectorized? For example: \n      - Is the algorithm amenable to SIMD or GPU parallelization (drawing rows and columns\n     in bulk and performing vectorized gathers)?  \n      - How does cLUT’s memory access pattern compare to typical GPU-friendly RNG kernels?\n\n3. **Memory–compute trade-off and practical break-even.**  \n   Figure 5 illustrates a break-even analysis in terms of energy and wall-clock time,\n   showing that cLUT’s higher preprocessing cost is amortized after sufficient draws.  \n   - Could the authors contextualize these numbers for typical workloads? For example,\n     how many discretized bins are required to approximate a continuous distribution\n     such as a Normal or Gamma to standard ML accuracy, and how many draws would that\n     entail in realistic training or inference runs?  \n4. **Code availability and reproducibility.**  \n   Will the authors release an open-source implementation, preferably an anonymous\n   repository for review, covering both CPU and GPU backends?  \n   Ideally, this should include scripts for rebuilding benchmark tables, integration\n   examples with PyTorch or JAX, and automated evaluation of time and energy metrics.\n   Such an implementation would be highly valuable for assessing portability and\n   adoption potential.", "limitations": "", "rating": 8, "confidence": 3, "soundness": 4, "presentation": 4, "contribution": 4, "strengths": "- **Conceptual elegance and originality.**  \n  The compression of frequency tables along binary bit-planes is a simple yet powerful\n  idea. It yields an exact, entropy-optimal sampling procedure that directly exploits\n  the binary nature of digital hardware. The resulting geometric–uniform two-step\n  sampling scheme is mathematically sound.\n\n- **Clarity and quality of exposition.**  \n  The paper is very well written, with intuitive explanations and instructive figures\n  (especially Figs. 1–2). The visual decomposition of frequencies into bit-planes makes\n  the algorithm conceptually understandable. \n\n- **Empirical thoroughness.**  \n  Benchmarks span both high-level (NumPy, PyTorch, JAX) and low-level (C)\n  implementations, reporting not only runtime but also energy via RAPL counters. The\n  TrueSkill case study convincingly demonstrates real-world impact, reducing both time\n  and energy while preserving statistical equivalence of posterior estimates.\n\n- **Practical significance.**  \n  Random number generation is a foundational operation across ML and simulation. A\n  method that is *exact*, *faster*, and *more energy-efficient* without sacrificing\n  correctness has immediate relevance for probabilistic modeling, simulation-based\n  inference, and on-device ML. The bit-level efficiency arguments also connect nicely to\n  ongoing discussions of energy-aware ML.\n\n- **Implementation simplicity.**  \n  The algorithm relies only on two primitive RNG calls: a geometric distribution\n  obtained from bit flips and a power-of-two uniform integer. Both are exact and\n  hardware-friendly. This makes the method easy to embed in existing frameworks.", "weaknesses": "- **Limited discussion of integration and practical deployment.**  \n  While the method is described cleanly, the paper provides little guidance on how cLUT\n  would be incorporated into standard frameworks such as `torch.distributions` or\n  `jax.random`. In practice, the preprocessing cost and table storage would need to be\n  managed per distribution instance or cached globally; a brief discussion of this would\n  clarify the usability pathway.\n\n- **Evaluation metric for TrueSkill comparison.**  \n  The comparison of posterior estimates between NumPy and cLUT uses t-tests on means.\n  This only probes first-moment agreement; distributional similarity could be assessed\n  more rigorously with two-sample metrics such as the **C2ST** score (which should\n  approach 0.5 for indistinguishable posteriors).\n\n- **Memory and break-even analysis.**  \n  Figure 5 shows clear scaling of preprocessing cost, but some contextualization would\n  help. For very large supports (e.g., $n>10^8$), achieving the theoretical break-even\n  might require enormous sample counts. Discussing typical discretization sizes for\n  common continuous distributions (Normal, Gamma, etc.) would make the results more\n  interpretable for practitioners.\n\n- **Minor editorial points.**  \n  Line 235: stray capital ‘T’.  \n  Line 236: slight mix-up in text; should read “is replaced by two a in the third row,\n  which corresponds to a frequency of 2.”\n\nThese are all minor and easily addressed; none affect the core soundness or clarity of\nthe work.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "QLbMv42YLp", "reviewer": "Reviewer_PkgD", "summary": "This paper proposes a new (to the best of my knowledge) method to generate random variables from arbitrary distributions, based on lookup tables. The approach is rather simple and well justified, and various benchmarks show a good improvement in time and energy savings with respect to state-of-the-art method.", "questions": "See weaknesses.", "limitations": "", "rating": 6, "confidence": 2, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "The paper is clear, the approach is sound and simple (in a good way) while being theoretically justified.\nSampling is not a huge bottleneck in most modern applications of machine learning, but it is always good to make things more efficient.", "weaknesses": "I would have appreciated a more in-depth discussion of limitations. It does not seem clear to me that this will completely replace existing approaches, as it is less \"out-of-the-box\" than those. \nAdditionally, while you touch upon one Bayesian learning application, the analysis is quite light. It would be better to include a more in depth analysis for a more standard application (such as a more complicated distribution, eg sampled with MC methods for bayesian posteriors).", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "qvsrS2RV3y", "reviewer": "Reviewer_5BMn", "summary": "This paper introduces cLUT (compressed Lookup Tables), a sampling method designed to generate samples from arbitrary discrete distributions efficiently. The authors claim that sampling, a core component of many machine learning algorithms is a significant computational and energy bottleneck.\n\nThe proposed method is based on two key contributions (1) a lossless compression scheme via a constructing a compressed lookup table and (2) a fast algorithm to sample efficiently given the compressed lookup table.\n\nThe authors provide a Python and C implementation of their algorithm. The results are demonstrate that the Python implementation of cLUT is 10-100x faster than standard Python samplers (NumPy, PyTorch, JAX), depending on the number of samples. The C implementation of cLUT is more energy-efficient and faster than state-of-the-art (SOTA) C-based samplers like ALDR, FLDR, and the Alias method. However, this efficiency comes at the cost of a higher one-time preprocessing step. The method's practical benefits are demonstrated in a modified TrueSkill application, where it significantly reduces execution time and energy consumption.", "questions": "I am wondering how generalizable the proposed method is. Is it possible to plug cLUT into pytorch so that all the sampling operations uses cLUT instead of whatever the default sampling algorithm is? If so, what would the end-to-end effect of such update be on a typical training/inference task?", "limitations": "", "rating": 6, "confidence": 2, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "**Significance**: The paper addresses a fundamental, practical, and important problem: the high energy and computational cost of sampling in ML. The claimed 33-60% energy savings and 10-100x speedup over common Python libraries is impressive.\n\n**Originality**: I am not an expert in the particular area of low-level implementation of sampling algorithms. But the core idea of combining a specific binary-expansion-based compression with a geometric-plus-uniform index sampling scheme appears to be novel.\n\n**Quality of evaluation**: The authors wisely compare against two separate groups: (1) high-level, commonly used Python libraries and (2) low-level, high-performance SOTA C implementations and demonstrate improved performance in terms of sampling time and energy efficiency across the board. They also will publicly release the implementation. The authors are upfront about the method's primary trade-off of cLUT's higher pre-processing time.\n\n**Clarity**: The paper is mostly well-written and is easy to follow. I have some suggestions for further improvements that are detialed in the next sections.", "weaknesses": "**Missing Algorithmic Details on Preprocessing**: The preprocessing step, which constructs the compressed table, is a critical part of the contribution but is not well-explained. The main text describes a \"rectification\" process to ensure all rows have a uniform width, which is essential for the sampling scheme. This section refers to Algorithm 2 in the appendix. However, Algorithm 2 is itself a high-level sketch. It calls a function distribute(z, f, r, c)  which seemingly performs all the work, but this function is undefined. The visual example in Figure 2 is helpful but insufficient to understand how this redistribution is performed algorithmically.\n\n**Vagueness on Key Parameter $r$**: The performance, compression ratio $\\rho = 2^r / (r+1)$, and bit efficiency are all critically dependent on the number of rows, $r$. The paper is vague on how $r$ is determined, stating it \"depend[s] on the frequencies f\". The formula provided in Algorithm 2 (Line 2) 33 is complex and presented without any derivation or intuition. The paper would be much stronger if it provided bounds or illustrative examples of what $r$ typically is for common distributions (e.g., uniform, Gaussian) at a given precision.\n\n**Limited ML Application Context**: The introduction strongly motivates the work by citing its relevance to VAEs, contrastive learning, and diffusion models. However, the evaluation only uses an extended TrueSkill system. While this is a valid real-world test, it is a relatively niche application. To compellingly demonstrate the paper's significance to the ICLR community, it would be far more powerful to show the effectiveness of plugging cLUT into even a small-scale generative model (like a VAE or a simple diffusion model) during training or inference. As is, the contribution feels more like a general-purpose algorithm paper than a paper demonstrating a clear impact on a core ML problem.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "XREmOyacsP", "reviewer": "Reviewer_QjRf", "summary": "This paper proposes a new sampling strategy for random variate generation from arbitrary distributions. The core idea is to construct a lossless compressed lookup table and perform efficient sampling from it. The approach to generating the compressed lookup table appears to be computationally efficient and potentially innovative.", "questions": "__Q1.__ In the conclusion section, you mention potential advantages of implementing your method on GPU. Since one of the comparisons is against GPU-accelerated libraries while your experiments are conducted only on the CPU, could you elaborate on these points in more detail? specifically, how these advantages arise compared to other methods and how they could be effectively leveraged or exploited in practice?\n\n__Q2.__ While many discrete sampling routines in Python packages use C++ backends, how do you ensure that Python wrapper overhead does not skew your runtime comparisons?\n\n__Q3.__ In Table 1, why is the sampling time faster for $n \\in [10^6, 10^7]$ in your proposed method compared to smaller $n$ ($n \\in [10^4, 10^5]$), while the other methods have slower sampling times when $n$ is larger?\n\n__Q4.__ It might be helpful to also show, in Figure 5, the peak memory usage excluding the preprocessing cases. Additionally, it would be nice to include other memory-related metric(s) such as average memory usage as well as the overall memory behavior during execution.\n\n__Minor__\n\n- In line 107, the real RAM assumption should be introduced more clearly, perhaps with one or two explanatory sentences or a short note in the appendix. Instead of only referring to Shamos (1978). At the minimum, please provide the abbreviation of RAM (Random Access Machine).\n- In line 149, while $c$ and $b$ are quite self-explanatory, it might be helpful to add a brief sentence explaining what $r$ represents to give readers a quick intuition. In general, a short description of all notation used could greatly improve the clarity of the paper.", "limitations": "", "rating": 8, "confidence": 1, "soundness": 3, "presentation": 4, "contribution": 3, "strengths": "The paper is well-written, and the experiments are sound. The baselines are well-chosen, ranging from generic Python library routines commonly used in the machine learning community to state-of-the-art competing methods for this particular task. The paper’s emphasis on energy efficiency is commendable and highlights an often-overlooked but important aspect of algorithmic design.", "weaknesses": "The absence of a computation complexity analysis appears to be the paper’s main weakness, though the authors may have a valid reason for omitting it.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)