amos 2f32624d3b Batch 18 (20261026-C-hwe-codegen-18): add 100 calibrated HWE code-gen tasks; pause production for rollout
100 tasks from the HWE arm-linux code-gen pool (outside the lk/man/pth
range given to batch 22), each with at least one independent
contract-edge defect and plain public docs. Claude reviewed 100/100
USABLE against current digests; no ID or source overlap with main or
batch 22. Difficulty is unmeasured.

progress.md records the wrap-up: all Codex sessions and Qwen schedulers
stopped for the user's rollout, Qwen results so far (57 HARD of 373),
and what is left on each batch branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 17:52:13 +08:00

131 lines
3.1 KiB
C++

#include "quant.hpp"
namespace aq {
namespace detail {
std::int64_t gcd(std::int64_t left, std::int64_t right)
{
if (left < 0) {
left = -left;
}
if (right < 0) {
right = -right;
}
while (right != 0) {
std::int64_t remainder = left % right;
left = right;
right = remainder;
}
return left;
}
Status normalize(const Profile& input, Profile& output)
{
if (input.num < 1 || input.num > 1000000) {
return Status::Scale;
}
if (input.den < 1 || input.den > 1000000) {
return Status::Scale;
}
if (input.zero < -128 || input.zero > 127) {
return Status::Zero;
}
if (input.low < -128 || input.low > 127) {
return Status::Range;
}
if (input.high < -128 || input.high > 127) {
return Status::Range;
}
if (input.low > input.high) {
return Status::Range;
}
if (input.zero < input.low || input.zero > input.high) {
return Status::Range;
}
Profile normalized = input;
std::int64_t divisor = gcd(input.num, input.den);
normalized.num /= divisor;
normalized.den /= divisor;
output = normalized;
return Status::Ok;
}
bool same(const Profile& left, const Profile& right)
{
if (left.num != right.num) {
return false;
}
if (left.den != right.den) {
return false;
}
if (left.zero != right.zero) {
return false;
}
if (left.low != right.low) {
return false;
}
return left.high == right.high;
}
bool valid(Rational value)
{
if (value.num < -1000000000 || value.num > 1000000000) {
return false;
}
if (value.den < 1 || value.den > 1000000) {
return false;
}
return true;
}
bool valid_code(int value)
{
return value >= -128 && value <= 127;
}
Rational reduce(std::int64_t numerator, std::int64_t denominator)
{
if (numerator == 0) {
return Rational{0, 1};
}
std::int64_t divisor = gcd(numerator, denominator);
Rational result;
result.num = numerator / divisor;
result.den = denominator / divisor;
return result;
}
int encode(const Profile& profile, Rational input, int& clipping)
{
const std::int64_t numerator = input.num * profile.den;
const std::int64_t denominator = input.den * profile.num;
const bool negative = numerator < 0;
const std::int64_t magnitude = negative ? -numerator : numerator;
std::int64_t rounded = magnitude / denominator;
const std::int64_t remainder = magnitude % denominator;
if (remainder * 2 >= denominator) {
++rounded;
}
if (negative) {
rounded = -rounded;
}
const std::int64_t shifted = rounded + profile.zero;
clipping = 0;
if (shifted < profile.low) {
clipping = -1;
return profile.low;
}
if (shifted > profile.high) {
clipping = 1;
return profile.high;
}
return static_cast<int>(shifted);
}
Rational decode(const Profile& profile, int input)
{
const std::int64_t distance = static_cast<std::int64_t>(input) - profile.zero;
return reduce(distance * profile.num, profile.den);
}
}
}