Stable log-sum-exp aggregation
ExponQuay is a Windows AI coding client for examining logarithmic aggregation in source files. Discuss the numeric contract with a compatible model, review its proposed maximum-shift calculation and test the extreme inputs before applying changes.
from math import exp, fsum, log, inf
def log_sum_exp(values):
if type(values) not in (list, tuple) or len(values) > 1000:
raise ValueError("values.container")
values = tuple(values)
if len(values) > 1000 or any(
type(v) not in (int, float) or not -1e300 <= v <= 1e300 for v in values
):
raise ValueError("values.range")
if not values:
return -inf
peak = max(values)
return peak + log(fsum(exp(v - peak) for v in values))| Review before applying | Compare actual behavior with the expected result. If a check fails, investigate it before applying more changes. |
|---|---|
| Connection | Base URL, credentials and a reachable server. |
| Project | Check empty input, repeated large values and very negative values, returning negative infinity only for empty input and rejecting Boolean, non-finite or out-of-range items. |
from math import exp, fsum, log, inf
def log_sum_exp(values):
if type(values) not in (list, tuple) or len(values) > 1000:
raise ValueError("values.container")
values = tuple(values)
if len(values) > 1000 or any(
type(v) not in (int, float) or not -1e300 <= v <= 1e300 for v in values
):
raise ValueError("values.range")
if not values:
return -inf
peak = max(values)
return peak + log(fsum(exp(v - peak) for v in values))Review numerical behavior before trusting the new result
ExponQuay is a Windows AI coding client for developers who need a numerical change explained in its application context. Bring the source, a problematic input and the expected behavior into the project conversation. A useful first request asks the connected model to separate the intended mathematical operation from the limitations of the current implementation.
For instance, a logarithmic aggregation task can specify bounded input values, a maximum collection size and an empty-input result. Ask the model to examine a maximum-shift approach while preserving that contract. Include the caller that consumes the answer, especially if it distinguishes an empty aggregate from a finite numerical result. The discussion remains about code in your project.
Before accepting the proposal, run cases with repeated large values and very negative values in your own environment. Check rejection of unsupported types and out-of-range input as well as the ordinary result. Compare against an appropriate reference for the precision your application needs. A method intended to improve stability still deserves verification on the workload it will actually serve.
Choose an OpenAI-compatible or Anthropic endpoint supported by ExponQuay. If unfiltered AI models are available there, you can select one with the required credentials. Its label does not promise mathematical precision; model restrictions, context limits and tool support depend on the actual endpoint and model configuration.
Preparing a numerical aggregation review
What belongs beside a troublesome numerical input?
Include the expected range or reference result, the accepted input types and the caller's treatment of special outputs. These facts let the conversation address the application's needs rather than simply replace one expression with a mathematically similar formula.
Should empty input return an ordinary number?
Follow the contract you specify. The example uses negative infinity for an empty aggregate, which the consumer must understand. Review that caller and test the empty case separately from very negative but valid inputs before accepting a proposed change.
Why test repeated large values?
They exercise a useful boundary for the aggregation approach discussed in this project example. State the expected behavior and compare the implementation with a suitable reference. Do not infer general numerical accuracy from a single ordinary fixture that avoids extreme values.
Can the model choose an acceptable error tolerance?
It can explain tradeoffs, but your application's requirements determine the tolerance. Supply that requirement and the numeric types in use. Run the resulting proposal against representative inputs with your own tools and document the limits observed during review.
ExponQuay · Updated 2026-10-25
