Tootfinder

"What is different, is that before what were largely fringe anti-Semitic and white supremacist theories floating around the far corners of the Alt-Right, have now become the backbone of the Republican party. 'The Great Replacement,' once a conspiracy pushed by only hardline neo-Nazis and white supremacists, is now being touted by everyone from pharma billionaire Vivek Ramaswamy, Swason frozen foods heir and Twitter troll Tucker Carlson, to the billionaire backed Turning Point US…

Invariant Generation for Floating-Point Programs via Constraint Solving
Xuran Cai, Liqian Chen, Hongfei Fu
https://arxiv.org/abs/2507.15017 https://…

Invariant Generation for Floating-Point Programs via Constraint Solving
In numeric-intensive computations, it is well known that the execution of floating-point programs is imprecise as floating point arithmetics (e.g., addition, subtraction, multiplication, division, etc.) incurs rounding errors. Albeit the rounding error is small for every single floating-point operation, the aggregation of such error in multiple operations may be dramatic and cause catastrophic program failures. Therefore, to ensure the correctness of floating-point programs, the effect of float…

Floating-Point Data Transformation for Lossless Compression
Samirasadat Jamalidinan, Kazem Cheshmi
https://arxiv.org/abs/2506.18062 https://

Floating-Point Data Transformation for Lossless Compression
Floating-point data is widely used across various domains. Depending on the required precision, each floating-point value can occupy several bytes. Lossless storage of this information is crucial due to its critical accuracy, as seen in applications such as medical imaging and language model weights. In these cases, data size is often significant, making lossless compression essential. Previous approaches either treat this data as raw byte streams for compression or fail to leverage all pattern…

from my link log —
Elementary functions NOT following the IEEE 754 floating-point standard.
http://www.hlsl.co.uk/blog/2020/1/29/ieee754-is-not-followed
saved 2025-02-11

Elementary Functions and NOT Following the IEEE 754 Floating-Point Standard — TRYING TO FIND THE OBVIOUS
The IEEE-754 Standard for floating-point numbers was introduced initially in 1985 to solve the problem of diverse floating point implementations prevent code being portable and increase stability across platforms. It has been widely adopted and revised over the last 30 years and if you have dealt

What Every Computer Scientist Should Know About Floating-Point Arithmetic #floats

Computing Floating-Point Errors by Injecting Perturbations
Youshuai Tan, Zhanwei Zhang, Jinfu Chen, Zishuo Ding, Jifeng Xuan, Weiyi Shang
https://arxiv.org/abs/2507.08467

Computing Floating-Point Errors by Injecting Perturbations
Floating-point programs form the foundation of modern science and engineering, providing the essential computational framework for a wide range of applications, such as safety-critical systems, aerospace engineering, and financial analysis. Floating-point errors can lead to severe consequences. Although floating-point errors widely exist, only a subset of inputs may trigger significant errors in floating-point programs. Therefore, it is crucial to determine whether a given input could produce s…

Analysis of Floating-Point Matrix Multiplication Computed via Integer Arithmetic
Ahmad Abdelfattah, Jack Dongarra, Massimiliano Fasi, Mantas Mikaitis, Fran\c{c}oise Tisseur
https://arxiv.org/abs/2506.11277

Analysis of Floating-Point Matrix Multiplication Computed via Integer Arithmetic
Ootomo, Ozaki, and Yokota [Int. J. High Perform. Comput. Appl., 38 (2024), p. 297-313] have proposed a strategy to recast a floating-point matrix multiplication in terms of integer matrix products. The factors A and B are split into integer slices, the product of these slices is computed exactly, and AB is approximated by accumulating these integer products in floating-point arithmetic. This technique is particularly well suited to mixed-precision matrix multiply-accumulate units with integer s…

Accurate Reduced Floating-Point Precision Implicit Monte Carlo
Simon Butson, Mathew Cleveland, Alex Long, Todd Palmer
https://arxiv.org/abs/2506.11962 http…

Accurate Reduced Floating-Point Precision Implicit Monte Carlo
This work describes methodologies to successfully implement the Implicit Monte Carlo (IMC) scheme for thermal radiative transfer in reduced-precision floating-point arithmetic. The methods used can be broadly categorized into scaling approaches and floating-point arithmetic manipulations. Scaling approaches entail re-scaling values to ensure computations stay within a representable range. Floating-point arithmetic manipulations involve changes to order of operations and alternative summation al…

«I guess the main point is understand the data types you’re using. You wouldn’t use an 8-bit integer to handle values in the thousands, but it’s fine if the values stay under one hundred. The same rules apply to floating point. You just have to know how they work.»
https://fosstodon.org/@drdrang/1147627…

everyone knows it's bad when your computer is dereferencing small integers that aren't a multiple of 4
however right now i'm looking at a function that's dereferencing a floating point value that it just multiplied by a denormal

from my link log —
Posit floating point numbers: thin triangles and other tricks.
http://marc-b-reynolds.github.io/math/2019/02/06/Posit1.html
saved 2025-06-18

NestedFP: High-Performance, Memory-Efficient Dual-Precision Floating Point Support for LLMs
Haeun Lee, Omin Kwon, Yeonhong Park, Jae W. Lee
https://arxiv.org/abs/2506.02024

NestedFP: High-Performance, Memory-Efficient Dual-Precision Floating Point Support for LLMs
Large Language Models (LLMs) are playing a crucial role in latency-critical, high-throughput services like virtual assistants and code generation. While techniques such as continuous batching and paged attention address service-level objectives (SLOs), and quantization methods accelerate inference, the dynamic and efficient adaptation of precision at runtime remains a significant, largely underexplored challenge. The emergence of hardware support for FP8 arithmetic, offering up to 2x the throug…

Effects of lower floating-point precision on scale-resolving numerical simulations of turbulence
Martin Karp, Ronith Stanly, Timofey Mukha, Luca Galimberti, Siavash Toosi, Hang Song, Lissandro Dalcin, Saleh Rezaeiravesh, Niclas Jansson, Stefano Markidis, Matteo Parsani, Sanjeeb Bose, Sanjiva Lele, Philipp Schlatter
https://arxiv…

Effects of lower floating-point precision on scale-resolving numerical simulations of turbulence
Modern computing clusters offer specialized hardware for reduced-precision arithmetic that can speed up the time to solution significantly. This is possible due to a decrease in data movement, as well as the ability to perform arithmetic operations at a faster rate. However, for high-fidelity simulations of turbulence, such as direct and large-eddy simulation, the impact of reduced precision on the computed solution and the resulting uncertainty across flow solvers and different flow cases have…

POLARON: Precision-aware On-device Learning and Adaptive Runtime-cONfigurable AI acceleration
Mukul Lokhande, Santosh Kumar Vishvakarma
https://arxiv.org/abs/2506.08785

POLARON: Precision-aware On-device Learning and Adaptive Runtime-cONfigurable AI acceleration
The increasing complexity of AI models requires flexible hardware capable of supporting diverse precision formats, particularly for energy-constrained edge platforms. This work presents PARV-CE, a SIMD-enabled, multi-precision MAC engine that performs efficient multiply-accumulate operations using a unified data-path for 4/8/16-bit fixed-point, floating point, and posit formats. The architecture incorporates a layer adaptive precision strategy to align computational accuracy with workload sensi…

SETI@home: Data Acquisition and Front-End Processing
Eric J. Korpela (Space Sciences Laboratory, University of California, Berkeley), David P. Anderson (Space Sciences Laboratory, University of California, Berkeley), Jeff Cobb (Space Sciences Laboratory, University of California, Berkeley), Matt Lebofsky (Space Sciences Laboratory, University of California, Berkeley), Wei Liu (Space Sciences Laboratory, University of California, Berkeley), Dan Werthimer (Space Sciences Laboratory, Univ…

SETI@home: Data Acquisition and Front-End Processing
SETI@home is a radio Search for Extraterrestrial Intelligence (SETI) project, looking for technosignatures in data recorded at multiple observatories from 1998 to 2020. Most radio SETI projects analyze data using dedicated processing hardware. SETI@home uses a different approach: time-domain data is distributed over the Internet to $\gt 10^{5}$ volunteered home computers, which analyze it. The large amount of computing power this affords ($\sim 10^{15}$ floating-point operations per second (FPO…

I read Bostrom's book SUPERINTELLIGENCE back when I worked at Google —
Blaise A— insisted that it go on the "AI" SF book club reading list
(as an aside: I started the book club; we were mostly reading, uh, cautionary stories)
SUPERINTELLIGENCE is garbage, & I said so: throw around big numbers until your moral calculus has a floating-point overflow & you can be convinced of obviously crazy things
(phrasing wasn't so clean at the time)
.…

Efficient vectorized evaluation of Gaussian AO integrals on modern central processing units
Andrey Asadchev, Edward F. Valeev
https://arxiv.org/abs/2506.12501

Efficient vectorized evaluation of Gaussian AO integrals on modern central processing units
We report an implementation of the McMurchie-Davidson evaluation scheme for 1- and 2-particle Gaussian AO integrals designed for efficient execution on modern central processing units (CPUs) with Single Instruction Multiple Data (SIMD) instruction sets. Like in our recent MD implementation for graphical processing units (GPUs) [J. Chem. Phys. 160, 244109 (2024)], variable-sized batches of shellsets of integrals are evaluated at a time. By optimizing for the floating point instruction throughput…

This https://arxiv.org/abs/2406.06095 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csMS_…

An extension of C++ with memory-centric specifications for HPC to reduce memory footprints and streamline MPI development
The C++ programming language and its cousins lean towards a memory-inefficient storage of structs: The compiler inserts helper bits such that individual instance variables fit to byte or cache boundaries, while it is not able to exploit knowledge about the range of integers, enums or bitsets. Furthermore, the language provides neither support for data exchange via MPI nor for arbitrary floating-point precisions. We propose C++ attributes through which developers can guide the compiler what memo…

Permutation-Avoiding FFT-Based Convolution
Nicolas Venkovic, Hartwig Anzt
https://arxiv.org/abs/2506.12718 https://arxiv.org/pdf/2506…

Permutation-Avoiding FFT-Based Convolution
Fast Fourier Transform (FFT) libraries are widely used for evaluating discrete convolutions. Most FFT implementations follow some variant of the Cooley-Tukey framework, in which the transform is decomposed into butterfly operations and index-reversal permutations. While butterfly operations dominate the floating-point operation count, the memory access patterns induced by index-reversal permutations significantly degrade the FFT's arithmetic intensity. In practice, discrete convolutions are oft…

on my blog!
performance of random floats
in which i examine the relative cost of bithacking floating point numbers vs more conventional conversions
https://dotat.at/@/2025-06-08-floats.html

Improving Deep Learning Framework Testing with Model-Level Metamorphic Testing
Yanzhou Mu, Juan Zhai, Chunrong Fang, Xiang Chen, Zhixiang Cao, Peiran Yang, Kexin Zhao, An Guo, Zhenyu Chen
https://arxiv.org/abs/2507.04354

Improving Deep Learning Framework Testing with Model-Level Metamorphic Testing
Deep learning (DL) frameworks are essential to DL-based software systems, and framework bugs may lead to substantial disasters, thus requiring effective testing. Researchers adopt DL models or single interfaces as test inputs and analyze their execution results to detect bugs. However, floating-point errors, inherent randomness, and the complexity of test inputs make it challenging to analyze execution results effectively, leading to existing methods suffering from a lack of suitable test oracl…

RAPTOR: Practical Numerical Profiling of Scientific Applications
Faveo Hoerold, Ivan R. Ivanov, Akash Dhruv, William S. Moses, Anshu Dubey, Mohamed Wahib, Jens Domke
https://arxiv.org/abs/2507.04647

RAPTOR: Practical Numerical Profiling of Scientific Applications
The proliferation of low-precision units in modern high-performance architectures increasingly burdens domain scientists. Historically, the choice in HPC was easy: can we get away with 32 bit floating-point operations and lower bandwidth requirements, or is FP64 necessary? Driven by Artificial Intelligence, vendors introduced novel low-precision units for vector and tensor operations, and FP64 capabilities stagnate or are reduced. This is forcing scientists to re-evaluate their codes, but a tri…

Jack Unit: An Area- and Energy-Efficient Multiply-Accumulate (MAC) Unit Supporting Diverse Data Formats
Seock-Hwan Noh, Sungju Kim, Seohyun Kim, Daehoon Kim, Jaeha Kung, Yeseong Kim
https://arxiv.org/abs/2507.04772

Jack Unit: An Area- and Energy-Efficient Multiply-Accumulate (MAC) Unit Supporting Diverse Data Formats
In this work, we introduce an area- and energy-efficient multiply-accumulate (MAC) unit, named Jack unit, that is a jack-of-all-trades, supporting various data formats such as integer (INT), floating point (FP), and microscaling data format (MX). It provides bit-level flexibility and enhances hardware efficiency by i) replacing the carry-save multiplier (CSM) in the FP multiplier with a precision-scalable CSM, ii) performing the adjustment of significands based on the exponent differences withi…

A Reduced Cost Two-component Relativistic Equation-of-Motion Coupled Cluster Method for Ionization Potential
Somesh Chamoli, Malaya K. Nayak, Achintya Kumar Dutta
https://arxiv.org/abs/2506.06805

A Reduced Cost Two-component Relativistic Equation-of-Motion Coupled Cluster Method for Ionization Potential
We report an efficient implementation of the ionization potential (IP) variant of the equation-of-motion coupled cluster (IP-EOM-CC) method based on the exact two-component atomic mean field (X2CAMF) framework, utilizing Cholesky decomposition (CD) and frozen natural spinors (FNS). The CD approximation significantly reduces memory demands, whereas the FNS approximation lowers the number of floating-point operations. Together, these techniques make the method computationally efficient for accura…

This https://arxiv.org/abs/2411.18065 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csAR_…

FlexiBit: Fully Flexible Precision Bit-parallel Accelerator Architecture for Arbitrary Mixed Precision AI
Recent research has shown that large language models (LLMs) can utilize low-precision floating point (FP) quantization to deliver high efficiency while maintaining original model accuracy. In particular, recent works have shown the effectiveness of non-power-of-two precisions, such as FP6 and FP5, and diverse sensitivity to low-precision arithmetic of LLM layers, which motivates mixed precision arithmetic including non-power-of-two precisions in LLMs. Although low-precision algorithmically lead…

Unicorn-CIM: Unconvering the Vulnerability and Improving the Resilience of High-Precision Compute-in-Memory
Qiufeng Li, Yiwen Liang, Weidong Cao
https://arxiv.org/abs/2506.02311

Unicorn-CIM: Unconvering the Vulnerability and Improving the Resilience of High-Precision Compute-in-Memory
Compute-in-memory (CIM) architecture has been widely explored to address the von Neumann bottleneck in accelerating deep neural networks (DNNs). However, its reliability remains largely understudied, particularly in the emerging domain of floating-point (FP) CIM, which is crucial for speeding up high-precision inference and on device training. This paper introduces Unicorn-CIM, a framework to uncover the vulnerability and improve the resilience of high-precision CIM, built on static r…

Efficient Precision-Scalable Hardware for Microscaling (MX) Processing in Robotics Learning
Stef Cuyckens, Xiaoling Yi, Nitish Satya Murthy, Chao Fang, Marian Verhelst
https://arxiv.org/abs/2505.22404

Efficient Precision-Scalable Hardware for Microscaling (MX) Processing in Robotics Learning
Autonomous robots require efficient on-device learning to adapt to new environments without cloud dependency. For this edge training, Microscaling (MX) data types offer a promising solution by combining integer and floating-point representations with shared exponents, reducing energy consumption while maintaining accuracy. However, the state-of-the-art continuous learning processor, namely Dacapo, faces limitations with its MXINT-only support and inefficient vector-based grouping during backpro…