One user-space repair task per eligible HWE debug-diag / compile-deploy base ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content filter. Each ships a public spec with a check-to-basis table, at least two defects with single-fix fixtures, a symptom-masking fixture and an alternative correct implementation. Claude re-checked all 320: structure, the HWE quality items and trace6 Docker calibration receipts against current digests (320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120 ad-hoc family names; the next batch maps them to the canonical list. The batch's 1,256-line progress log stays in its factory report and the 36-local branch batch15-hwe. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
204 lines
5.9 KiB
C
204 lines
5.9 KiB
C
#include "array_report.h"
|
|
|
|
static void prefix_extremes(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
long long prefix = 0;
|
|
long long lower = 0;
|
|
long long upper = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
prefix += cells[index].value;
|
|
if (prefix < lower) {
|
|
lower = prefix;
|
|
}
|
|
if (prefix > upper) {
|
|
upper = prefix;
|
|
}
|
|
}
|
|
report->v[36] = lower;
|
|
report->v[37] = upper;
|
|
}
|
|
|
|
static void sign_segments(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
size_t positive_runs = 0;
|
|
size_t negative_runs = 0;
|
|
size_t positive_longest = 0;
|
|
size_t negative_longest = 0;
|
|
size_t positive_length = 0;
|
|
size_t negative_length = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
int value = cells[index].value;
|
|
if (value > 0) {
|
|
if (positive_length == 0) {
|
|
positive_runs += 1;
|
|
}
|
|
positive_length += 1;
|
|
negative_length = 0;
|
|
} else if (value < 0) {
|
|
if (negative_length == 0) {
|
|
negative_runs += 1;
|
|
}
|
|
negative_length += 1;
|
|
positive_length = 0;
|
|
} else {
|
|
positive_length = 0;
|
|
negative_length = 0;
|
|
}
|
|
if (positive_length > positive_longest) {
|
|
positive_longest = positive_length;
|
|
}
|
|
if (negative_length > negative_longest) {
|
|
negative_longest = negative_length;
|
|
}
|
|
}
|
|
report->v[38] = (long long)positive_runs;
|
|
report->v[39] = (long long)negative_runs;
|
|
report->v[40] = (long long)positive_longest;
|
|
report->v[41] = (long long)negative_longest;
|
|
}
|
|
|
|
static void neighbour_shape(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
long long peaks = 0;
|
|
long long valleys = 0;
|
|
long long equal_pairs = 0;
|
|
long long correlation = 0;
|
|
for (size_t index = 1; index < size; ++index) {
|
|
long long previous = cells[index - 1].value;
|
|
long long current = cells[index].value;
|
|
correlation += previous * current;
|
|
if (previous == current) {
|
|
equal_pairs += 1;
|
|
}
|
|
if (index + 1 < size) {
|
|
long long next = cells[index + 1].value;
|
|
if (current > previous && current > next) {
|
|
peaks += 1;
|
|
}
|
|
if (current < previous && current < next) {
|
|
valleys += 1;
|
|
}
|
|
}
|
|
}
|
|
report->v[42] = peaks;
|
|
report->v[43] = valleys;
|
|
report->v[44] = equal_pairs;
|
|
report->v[45] = correlation;
|
|
}
|
|
|
|
static void position_gaps(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
long long largest = 0;
|
|
long long missing = 0;
|
|
for (size_t index = 1; index < size; ++index) {
|
|
long long gap = (long long)cells[index].position - cells[index - 1].position - 1;
|
|
missing += gap;
|
|
if (gap > largest) {
|
|
largest = gap;
|
|
}
|
|
}
|
|
report->v[46] = largest;
|
|
report->v[47] = missing;
|
|
}
|
|
|
|
static size_t subsequence(const ra_cell *cells, size_t size, int descending)
|
|
{
|
|
size_t lengths[RA_LIMIT];
|
|
size_t best = 0;
|
|
for (size_t end = 0; end < size; ++end) {
|
|
size_t length = 1;
|
|
for (size_t previous = 0; previous < end; ++previous) {
|
|
int earlier = cells[previous].value;
|
|
int later = cells[end].value;
|
|
int follows = descending ? earlier > later : earlier < later;
|
|
if (follows && lengths[previous] + 1 > length) {
|
|
length = lengths[previous] + 1;
|
|
}
|
|
}
|
|
lengths[end] = length;
|
|
if (length > best) {
|
|
best = length;
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
static void frequent_value(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
size_t best_count = 0;
|
|
int best_value = 0;
|
|
long long pairs = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
size_t count = 0;
|
|
for (size_t other = 0; other < size; ++other) {
|
|
if (cells[other].value == cells[index].value) {
|
|
count += 1;
|
|
if (other > index) {
|
|
pairs += 1;
|
|
}
|
|
}
|
|
}
|
|
if (count > best_count) {
|
|
best_count = count;
|
|
best_value = cells[index].value;
|
|
}
|
|
}
|
|
report->v[50] = best_value;
|
|
report->v[51] = (long long)best_count;
|
|
report->v[52] = pairs;
|
|
}
|
|
|
|
static long long alternating_sum(const ra_cell *cells, size_t size)
|
|
{
|
|
long long result = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
if (index % 2 == 0) {
|
|
result += cells[index].value;
|
|
} else {
|
|
result -= cells[index].value;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void crossing_plateau(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
long long changes = 0;
|
|
int previous_sign = 0;
|
|
size_t plateau = 0;
|
|
size_t longest = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
int value = cells[index].value;
|
|
int sign = (value > 0) - (value < 0);
|
|
if (sign != 0) {
|
|
if (previous_sign != 0 && previous_sign != sign) {
|
|
changes += 1;
|
|
}
|
|
previous_sign = sign;
|
|
}
|
|
if (index != 0 && value == cells[index - 1].value) {
|
|
plateau += 1;
|
|
} else {
|
|
plateau = 1;
|
|
}
|
|
if (plateau > longest) {
|
|
longest = plateau;
|
|
}
|
|
}
|
|
report->v[54] = changes;
|
|
report->v[55] = (long long)longest;
|
|
}
|
|
|
|
void ra_trends(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
crossing_plateau(cells, size, report);
|
|
prefix_extremes(cells, size, report);
|
|
sign_segments(cells, size, report);
|
|
neighbour_shape(cells, size, report);
|
|
position_gaps(cells, size, report);
|
|
report->v[48] = (long long)subsequence(cells, size, 0);
|
|
report->v[49] = (long long)subsequence(cells, size, 1);
|
|
frequent_value(cells, size, report);
|
|
report->v[53] = alternating_sum(cells, size);
|
|
}
|