A Large-Scale Study of Floating-Point Usage in Statically Typed Languages

2025-09-05

AI Summary

A critical gap exists between the design of floating-point (FP) tools and real-world usage patterns in statically typed languages, due to the lack of large-scale empirical evidence on actual FP practices. Method: We conducted the first large-scale, empirical study of FP usage across 12,000+ open-source GitHub projects. Our methodology combined keyword-based filtering, syntactic parsing, random sampling, intrinsic property filtering, and static analysis to construct the first unbiased, reproducible FP code corpus. Contribution/Results: We find that FP operations are pervasive yet highly concentrated in specific idioms; mainstream FP benchmarks (e.g., FPBench, ROSE) exhibit significant distributional biases—diverging markedly from real code in operator frequency, precision requirements, and contextual complexity. This work provides foundational empirical evidence and a rigorously curated dataset to guide the design, evaluation, and optimization of FP analysis, verification, and compilation tools.

Technology Category

• Reasoning under Uncertainty: Probabilistic Programming
• Natural Language Processing: Code Generation / Program Synthesis from Natural Language
• Search and Optimization: Sampling/Simulation-based Search

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Security and Privacy: Large-scale security measurements
• Web Mining and Content Analysis: Web data provenance, reliability, and authenticity

Abstract

Reasoning about floating-point arithmetic is notoriously hard. While static and dynamic analysis techniques or program repair have made significant progress, more work is still needed to make them relevant to real-world code. On the critical path to that goal is understanding what real-world floating-point code looks like. To close that knowledge gap, this paper presents the first large-scale empirical study of floating-point arithmetic usage in statically typed languages across public GitHub repositories. We follow state-of the art mining practices including random sampling and filtering based on only intrinsic properties to avoid bias, and identify floating-point usage by searching for keywords in the source code, and programming language constructs (e.g., loops) by parsing the code. Our evaluation supports the claim often made in papers that floating-point arithmetic is widely used. Comparing statistics such as size and usage of certain constructs and functions, we find that benchmarks used in literature to evaluate automated reasoning techniques for floating-point arithmetic are in certain aspects representative of 'real-world' code, but not in all. We aim for our study and dataset to help future techniques for floating-point arithmetic to be designed and evaluated to match actual users' expectations.

Problem

• Analyzing floating-point usage in real-world code
• Evaluating representativeness of floating-point benchmarks
• Understanding floating-point arithmetic in statically typed languages

Innovation

• Large-scale empirical study of floating-point usage
• Random sampling and intrinsic property filtering
• Source code parsing for language constructs