Measure aggregate cost and fidelity across scarcity scenarios
This commit is contained in:
+12
-524
@@ -1,5 +1,6 @@
|
||||
#include "evo/ecology/materialize.hpp"
|
||||
#include "evo/ecology/population.hpp"
|
||||
#include "fixtures/resolution_model.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
@@ -23,513 +24,8 @@ void check(bool condition, std::source_location location = std::source_location:
|
||||
}
|
||||
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// The rule. Written once, applied at both resolutions: the individual run gives
|
||||
// it one member at a time and the aggregate run gives it a class average and
|
||||
// multiplies by the count. It is a fixture constant, not a simulation contract:
|
||||
// ADR-0038 deliberately declines to choose an ecology, and this does not choose
|
||||
// one for it. Energy is the only scarce axis so that divergence is attributable.
|
||||
// ---------------------------------------------------------------------------
|
||||
namespace rule {
|
||||
constexpr std::uint64_t environment_energy = 300; // per tick, shared by the living
|
||||
constexpr std::uint64_t matter_intake = 4; // per member per tick, abundant
|
||||
constexpr std::uint64_t upkeep_energy = 2;
|
||||
constexpr std::uint64_t upkeep_matter = 1;
|
||||
constexpr std::uint64_t lifespan = 400;
|
||||
constexpr std::uint64_t maturity = 50;
|
||||
constexpr std::uint64_t threshold_energy = 100;
|
||||
constexpr std::uint64_t investment_energy = 40;
|
||||
constexpr std::uint64_t investment_matter = 40;
|
||||
constexpr std::uint64_t capacity = 200;
|
||||
|
||||
// A member that cannot pay its upkeep starves. At class resolution the average
|
||||
// member is asked the same question, which is exactly where the resolution bites.
|
||||
[[nodiscard]] constexpr bool starves(std::uint64_t energy) noexcept {
|
||||
return energy < upkeep_energy;
|
||||
}
|
||||
[[nodiscard]] constexpr bool breeds(std::uint64_t age, std::uint64_t energy) noexcept {
|
||||
return age >= maturity && energy >= threshold_energy;
|
||||
}
|
||||
[[nodiscard]] constexpr std::uint64_t per_capita(std::uint64_t living) noexcept {
|
||||
return living == 0 ? 0 : environment_energy / living;
|
||||
}
|
||||
// Who breeds when there are fewer free slots than eligible parents. This has to be
|
||||
// part of the rule rather than a consequence of how each run happens to iterate:
|
||||
// allocating contested slots in different orders changes which parents reproduce
|
||||
// independently of any averaging, and a divergence caused by that is not a
|
||||
// divergence caused by resolution. Oldest first, which both resolutions can honour:
|
||||
// classes partition ages, so the oldest class holds the oldest members. Ordering
|
||||
// within a class is the one thing only the individual run can see, and that is a
|
||||
// resolution effect rather than an implementation difference.
|
||||
} // namespace rule
|
||||
|
||||
// Matter behaves identically in all four channels here, so one number is tracked
|
||||
// and mirrored into the four. Stated rather than left for a reader to infer.
|
||||
Inventory spread(std::uint64_t energy, std::uint64_t matter) {
|
||||
return {{energy},
|
||||
{Femtograms{matter}, Femtograms{matter}, Femtograms{matter}, Femtograms{matter}}};
|
||||
}
|
||||
|
||||
struct Census {
|
||||
std::uint64_t living{};
|
||||
std::uint64_t energy{};
|
||||
std::uint64_t matter{};
|
||||
std::uint64_t births{};
|
||||
std::uint64_t deaths{};
|
||||
auto operator<=>(const Census&) const = default;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Individual resolution. Inventory is tracked as plain values and conservation is
|
||||
// asserted arithmetically: this is the reference fixture, not a contract, and a
|
||||
// reservoir per member would exceed the ledger's per-transaction leg bound.
|
||||
// ---------------------------------------------------------------------------
|
||||
struct Member {
|
||||
std::uint64_t age{};
|
||||
std::uint64_t energy{};
|
||||
std::uint64_t matter{};
|
||||
bool alive{true};
|
||||
};
|
||||
|
||||
struct IndividualRun {
|
||||
std::vector<Member> members;
|
||||
std::uint64_t environment{};
|
||||
std::uint64_t detritus_energy{};
|
||||
std::uint64_t detritus_matter{};
|
||||
std::uint64_t matter_store{};
|
||||
std::uint64_t births{};
|
||||
std::uint64_t deaths{};
|
||||
std::uint64_t capacity{rule::capacity};
|
||||
|
||||
[[nodiscard]] Census census() const {
|
||||
Census now;
|
||||
for (const auto& member : members) {
|
||||
if (!member.alive) {
|
||||
continue;
|
||||
}
|
||||
++now.living;
|
||||
now.energy += member.energy;
|
||||
now.matter += member.matter;
|
||||
}
|
||||
now.births = births;
|
||||
now.deaths = deaths;
|
||||
return now;
|
||||
}
|
||||
[[nodiscard]] std::uint64_t total_energy() const {
|
||||
std::uint64_t total = environment + detritus_energy;
|
||||
for (const auto& member : members) {
|
||||
if (member.alive) {
|
||||
total += member.energy;
|
||||
}
|
||||
}
|
||||
return total;
|
||||
}
|
||||
[[nodiscard]] std::uint64_t total_matter() const {
|
||||
std::uint64_t total = matter_store + detritus_matter;
|
||||
for (const auto& member : members) {
|
||||
if (member.alive) {
|
||||
total += member.matter;
|
||||
}
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
void step() {
|
||||
std::uint64_t living = 0;
|
||||
for (const auto& member : members) {
|
||||
living += member.alive ? 1 : 0;
|
||||
}
|
||||
const auto share = rule::per_capita(living);
|
||||
// Starvation first, then upkeep, then intake, then ageing, then breeding.
|
||||
// The aggregate run applies the same five stages in the same order.
|
||||
for (auto& member : members) {
|
||||
if (!member.alive) {
|
||||
continue;
|
||||
}
|
||||
if (rule::starves(member.energy)) {
|
||||
member.alive = false;
|
||||
detritus_energy += member.energy;
|
||||
detritus_matter += member.matter;
|
||||
member.energy = 0;
|
||||
member.matter = 0;
|
||||
++deaths;
|
||||
}
|
||||
}
|
||||
for (auto& member : members) {
|
||||
if (!member.alive) {
|
||||
continue;
|
||||
}
|
||||
member.energy -= rule::upkeep_energy;
|
||||
detritus_energy += rule::upkeep_energy;
|
||||
const auto paid = std::min(member.matter, rule::upkeep_matter);
|
||||
member.matter -= paid;
|
||||
detritus_matter += paid;
|
||||
}
|
||||
for (auto& member : members) {
|
||||
if (!member.alive) {
|
||||
continue;
|
||||
}
|
||||
// Bounded by what is there, so the arithmetic is safe, but the fixture
|
||||
// is sized so that it never binds: if it ever did, intake would depend
|
||||
// on the order members are visited in, and a divergence caused by that
|
||||
// would look like a divergence caused by resolution. Checked rather
|
||||
// than assumed, on both sides.
|
||||
check(environment >= share);
|
||||
check(matter_store >= rule::matter_intake);
|
||||
const auto taken = std::min(share, environment);
|
||||
environment -= taken;
|
||||
member.energy += taken;
|
||||
const auto gathered = std::min(rule::matter_intake, matter_store);
|
||||
matter_store -= gathered;
|
||||
member.matter += gathered;
|
||||
}
|
||||
for (auto& member : members) {
|
||||
if (!member.alive) {
|
||||
continue;
|
||||
}
|
||||
++member.age;
|
||||
if (member.age >= rule::lifespan) {
|
||||
member.alive = false;
|
||||
detritus_energy += member.energy;
|
||||
detritus_matter += member.matter;
|
||||
member.energy = 0;
|
||||
member.matter = 0;
|
||||
++deaths;
|
||||
}
|
||||
}
|
||||
std::uint64_t population = 0;
|
||||
for (const auto& member : members) {
|
||||
population += member.alive ? 1 : 0;
|
||||
}
|
||||
// Oldest first, as the rule requires, with the index breaking ties so the
|
||||
// order is total. Insertion order would have allocated contested slots to
|
||||
// different parents than the aggregate run does, which would have shown up
|
||||
// in the comparison as if resolution had caused it.
|
||||
std::vector<std::size_t> eligible;
|
||||
for (std::size_t index = 0; index < members.size(); ++index) {
|
||||
const auto& member = members[index];
|
||||
if (!member.alive || !rule::breeds(member.age, member.energy)) {
|
||||
continue;
|
||||
}
|
||||
if (member.matter < rule::investment_matter) {
|
||||
continue;
|
||||
}
|
||||
eligible.push_back(index);
|
||||
}
|
||||
std::ranges::sort(eligible, [&](std::size_t left, std::size_t right) {
|
||||
if (members[left].age != members[right].age) {
|
||||
return members[left].age > members[right].age;
|
||||
}
|
||||
return left < right;
|
||||
});
|
||||
for (const auto index : eligible) {
|
||||
if (population >= capacity) {
|
||||
break;
|
||||
}
|
||||
auto& member = members[index];
|
||||
member.energy -= rule::investment_energy;
|
||||
member.matter -= rule::investment_matter;
|
||||
members.push_back({0, rule::investment_energy, rule::investment_matter, true});
|
||||
++population;
|
||||
++births;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
IndividualRun founding_individuals(std::uint64_t count) {
|
||||
IndividualRun run;
|
||||
// Deliberately spread: variation is what averaging destroys, so a fixture
|
||||
// where everyone is identical would measure nothing.
|
||||
for (std::uint64_t index = 0; index < count; ++index) {
|
||||
run.members.push_back({index % 60, 20 + index, 50 + index, true});
|
||||
}
|
||||
run.environment = 100'000'000;
|
||||
run.matter_store = 100'000'000;
|
||||
return run;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Aggregate resolution. Real cohort records, real ledger, real conversions. The
|
||||
// class state is advanced by the same five stages applied to a class average.
|
||||
// ---------------------------------------------------------------------------
|
||||
struct AggregateClass {
|
||||
std::uint64_t age_low{};
|
||||
std::uint64_t age_high{};
|
||||
std::uint64_t count{};
|
||||
std::uint64_t energy{}; // held by the class in total
|
||||
std::uint64_t matter{};
|
||||
};
|
||||
|
||||
struct AggregateRun {
|
||||
std::vector<AggregateClass> classes;
|
||||
std::uint64_t width{};
|
||||
std::uint64_t environment{};
|
||||
std::uint64_t matter_store{};
|
||||
std::uint64_t detritus_energy{};
|
||||
std::uint64_t detritus_matter{};
|
||||
std::uint64_t births{};
|
||||
std::uint64_t deaths{};
|
||||
std::uint64_t capacity{rule::capacity};
|
||||
|
||||
[[nodiscard]] Census census() const {
|
||||
Census now;
|
||||
for (const auto& age : classes) {
|
||||
now.living += age.count;
|
||||
now.energy += age.energy;
|
||||
now.matter += age.matter;
|
||||
}
|
||||
now.births = births;
|
||||
now.deaths = deaths;
|
||||
return now;
|
||||
}
|
||||
[[nodiscard]] std::uint64_t total_energy() const {
|
||||
std::uint64_t total = environment + detritus_energy;
|
||||
for (const auto& age : classes) {
|
||||
total += age.energy;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
[[nodiscard]] std::uint64_t total_matter() const {
|
||||
std::uint64_t total = matter_store + detritus_matter;
|
||||
for (const auto& age : classes) {
|
||||
total += age.matter;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
void step() {
|
||||
std::uint64_t living = 0;
|
||||
for (const auto& age : classes) {
|
||||
living += age.count;
|
||||
}
|
||||
const auto share = rule::per_capita(living);
|
||||
// Starvation, judged on the class average. This is the resolution error:
|
||||
// the average pays for everyone until it cannot, and then the class goes
|
||||
// together, where individuals would have starved one at a time.
|
||||
for (auto& age : classes) {
|
||||
if (age.count == 0) {
|
||||
continue;
|
||||
}
|
||||
if (rule::starves(age.energy / age.count)) {
|
||||
detritus_energy += age.energy;
|
||||
detritus_matter += age.matter;
|
||||
deaths += age.count;
|
||||
age.count = 0;
|
||||
age.energy = 0;
|
||||
age.matter = 0;
|
||||
}
|
||||
}
|
||||
std::erase_if(classes, [](const AggregateClass& age) { return age.count == 0; });
|
||||
for (auto& age : classes) {
|
||||
const auto owed = rule::upkeep_energy * age.count;
|
||||
age.energy -= owed;
|
||||
detritus_energy += owed;
|
||||
const auto paid = std::min(age.matter, rule::upkeep_matter * age.count);
|
||||
age.matter -= paid;
|
||||
detritus_matter += paid;
|
||||
}
|
||||
for (auto& age : classes) {
|
||||
const auto wanted = share * age.count;
|
||||
// The same bound, and the same reason for checking it: a shared store
|
||||
// that ran out would make intake depend on the order classes are
|
||||
// visited in, which is not a resolution effect.
|
||||
check(environment >= wanted);
|
||||
check(matter_store >= rule::matter_intake * age.count);
|
||||
const auto taken = std::min(wanted, environment);
|
||||
environment -= taken;
|
||||
age.energy += taken;
|
||||
const auto gathered = std::min(rule::matter_intake * age.count, matter_store);
|
||||
matter_store -= gathered;
|
||||
age.matter += gathered;
|
||||
}
|
||||
// Ageing shifts the class bounds rather than moving members between
|
||||
// classes, so no member ever has to be placed by an age the record cannot
|
||||
// know. A class is a birth cohort and stays one.
|
||||
for (auto& age : classes) {
|
||||
++age.age_low;
|
||||
++age.age_high;
|
||||
}
|
||||
for (auto& age : classes) {
|
||||
if (age.age_low >= rule::lifespan) {
|
||||
detritus_energy += age.energy;
|
||||
detritus_matter += age.matter;
|
||||
deaths += age.count;
|
||||
age.count = 0;
|
||||
age.energy = 0;
|
||||
age.matter = 0;
|
||||
}
|
||||
}
|
||||
std::erase_if(classes, [](const AggregateClass& age) { return age.count == 0; });
|
||||
std::uint64_t population = 0;
|
||||
for (const auto& age : classes) {
|
||||
population += age.count;
|
||||
}
|
||||
std::uint64_t newborns = 0;
|
||||
std::uint64_t taken_energy = 0;
|
||||
std::uint64_t taken_matter = 0;
|
||||
// Oldest class first, which is the same allocation rule the individual run
|
||||
// follows. The classes are held youngest-first, so this walks them in
|
||||
// reverse rather than relying on the storage order.
|
||||
for (auto& age : std::ranges::reverse_view(classes)) {
|
||||
if (age.count == 0 || population + newborns >= capacity) {
|
||||
continue;
|
||||
}
|
||||
const auto average_energy = age.energy / age.count;
|
||||
const auto average_matter = age.matter / age.count;
|
||||
if (!rule::breeds(age.age_low, average_energy)) {
|
||||
continue;
|
||||
}
|
||||
if (average_matter < rule::investment_matter) {
|
||||
continue;
|
||||
}
|
||||
auto breeding = age.count;
|
||||
if (population + newborns + breeding > capacity) {
|
||||
breeding = capacity - population - newborns;
|
||||
}
|
||||
const auto energy_moved = rule::investment_energy * breeding;
|
||||
const auto matter_moved = rule::investment_matter * breeding;
|
||||
if (energy_moved > age.energy || matter_moved > age.matter) {
|
||||
continue;
|
||||
}
|
||||
age.energy -= energy_moved;
|
||||
age.matter -= matter_moved;
|
||||
taken_energy += energy_moved;
|
||||
taken_matter += matter_moved;
|
||||
newborns += breeding;
|
||||
}
|
||||
if (newborns > 0) {
|
||||
// Ageing shifted every class up by one, so nothing now starts at zero.
|
||||
// The youngest class is extended down to cover the newborns while it is
|
||||
// still narrower than the declared width, and otherwise a new one
|
||||
// opens. That keeps the classes contiguous, ascending and never wider
|
||||
// than the width, which is what makes the state a representable
|
||||
// cohort: bounds that merely shift would overlap the moment a class
|
||||
// was opened part way through an interval.
|
||||
const auto at = std::ranges::min_element(
|
||||
classes, {}, [](const AggregateClass& age) { return age.age_low; });
|
||||
if (at != classes.end() && at->age_low == 1 && at->age_high - at->age_low < width) {
|
||||
at->age_low = 0;
|
||||
at->count += newborns;
|
||||
at->energy += taken_energy;
|
||||
at->matter += taken_matter;
|
||||
} else {
|
||||
classes.push_back({0, 1, newborns, taken_energy, taken_matter});
|
||||
}
|
||||
births += newborns;
|
||||
} else {
|
||||
// A class that opened and then had no births still has to grow to the
|
||||
// declared width rather than staying one tick wide for ever, or the
|
||||
// structure would drift towards one class per tick.
|
||||
const auto at = std::ranges::min_element(
|
||||
classes, {}, [](const AggregateClass& age) { return age.age_low; });
|
||||
if (at != classes.end() && at->age_low == 1 && at->age_high - at->age_low < width) {
|
||||
at->age_low = 0;
|
||||
}
|
||||
}
|
||||
std::ranges::sort(classes, {}, [](const AggregateClass& age) { return age.age_low; });
|
||||
}
|
||||
};
|
||||
|
||||
AggregateRun founding_classes(const IndividualRun& source, std::uint64_t width) {
|
||||
AggregateRun run;
|
||||
run.width = width;
|
||||
run.environment = source.environment;
|
||||
run.matter_store = source.matter_store;
|
||||
for (const auto& member : source.members) {
|
||||
if (!member.alive) {
|
||||
continue;
|
||||
}
|
||||
const auto low = member.age / width * width;
|
||||
const auto at = std::ranges::find_if(
|
||||
run.classes, [&](const AggregateClass& age) { return age.age_low == low; });
|
||||
if (at == run.classes.end()) {
|
||||
run.classes.push_back({low, low + width, 1, member.energy, member.matter});
|
||||
} else {
|
||||
++at->count;
|
||||
at->energy += member.energy;
|
||||
at->matter += member.matter;
|
||||
}
|
||||
}
|
||||
std::ranges::sort(run.classes, {}, [](const AggregateClass& age) { return age.age_low; });
|
||||
check(run.classes.size() <= max_age_classes);
|
||||
return run;
|
||||
}
|
||||
|
||||
// Whether the aggregate state is something a cohort record can actually hold. The
|
||||
// experiment is worthless if it measures a model the library could not represent,
|
||||
// so this is checked at every step rather than assumed.
|
||||
[[nodiscard]] bool representable(const AggregateRun& run) {
|
||||
if (run.classes.empty()) {
|
||||
return true; // Vacancy is representable; ADR-0036 has a factory for it.
|
||||
}
|
||||
CohortDraft probe;
|
||||
probe.representation_version = cohort_representation_version;
|
||||
probe.habitat = {7};
|
||||
probe.genome = 3;
|
||||
probe.owner = {11, 1};
|
||||
probe.last_tick = Tick{0};
|
||||
probe.revision = 1;
|
||||
probe.conversion = 1;
|
||||
probe.reservoir = {1};
|
||||
for (const auto& age : run.classes) {
|
||||
probe.classes.push_back(
|
||||
{age.age_low, age.age_high, age.count, spread(age.energy, age.matter), 0});
|
||||
}
|
||||
return Cohort::create(std::move(probe)).has_value();
|
||||
}
|
||||
|
||||
// Every living member as (age, energy, matter), sorted. Comparing censuses is not
|
||||
// enough to establish that the two runs allocate contested breeding slots to the
|
||||
// same parents: whoever breeds hands the same investment to a child either way, so
|
||||
// the totals agree while the distribution does not, and the disagreement only
|
||||
// reaches a census many ticks later. The control therefore compares distributions.
|
||||
using Portrait = std::vector<std::array<std::uint64_t, 3>>;
|
||||
|
||||
[[nodiscard]] Portrait portrait(const IndividualRun& run) {
|
||||
Portrait rows;
|
||||
for (const auto& member : run.members) {
|
||||
if (member.alive) {
|
||||
rows.push_back({member.age, member.energy, member.matter});
|
||||
}
|
||||
}
|
||||
std::ranges::sort(rows);
|
||||
return rows;
|
||||
}
|
||||
// Only meaningful at width one, where a class holds members of a single age. A
|
||||
// class may still hold several of them, because several can be born in one tick, so
|
||||
// each is expanded into its equal share; the division has to be exact or the
|
||||
// expansion would not be the distribution it claims to be, and that is checked
|
||||
// rather than assumed.
|
||||
[[nodiscard]] Portrait portrait(const AggregateRun& run) {
|
||||
Portrait rows;
|
||||
for (const auto& age : run.classes) {
|
||||
check(age.count > 0);
|
||||
check(age.energy % age.count == 0);
|
||||
check(age.matter % age.count == 0);
|
||||
for (std::uint64_t index = 0; index < age.count; ++index) {
|
||||
rows.push_back({age.age_low, age.energy / age.count, age.matter / age.count});
|
||||
}
|
||||
}
|
||||
std::ranges::sort(rows);
|
||||
return rows;
|
||||
}
|
||||
|
||||
// Ages ascend with the index, so the oldest member is the last inserted and the
|
||||
// youngest class is the first stored. Oldest-first therefore disagrees with both of
|
||||
// the orders this fixture could have drifted into: allocating in insertion order
|
||||
// would pick the first member, and walking the classes as stored would pick the
|
||||
// youngest class. Each of those, introduced alone, makes the two runs choose
|
||||
// different parents, which is what the control has to be able to see.
|
||||
IndividualRun founding_contested(std::uint64_t count, std::uint64_t capacity) {
|
||||
IndividualRun run;
|
||||
for (std::uint64_t index = 0; index < count; ++index) {
|
||||
run.members.push_back({rule::maturity + index, 100 + index, 60 + index, true});
|
||||
}
|
||||
run.environment = 100'000'000;
|
||||
run.matter_store = 100'000'000;
|
||||
run.capacity = capacity;
|
||||
return run;
|
||||
}
|
||||
using namespace evo::fixture;
|
||||
constexpr Rule rule{};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// The instrument check. With one member per class a class average is that member,
|
||||
@@ -575,7 +71,7 @@ void contested_breeding_slots_go_to_the_same_parents() {
|
||||
constexpr std::uint64_t count = 12;
|
||||
auto individual = founding_contested(count, count + 1);
|
||||
auto aggregate = founding_classes(individual, 1);
|
||||
aggregate.capacity = individual.capacity;
|
||||
CHECK(aggregate.rule.capacity == individual.rule.capacity);
|
||||
CHECK(aggregate.classes.size() == count);
|
||||
CHECK(portrait(individual) == portrait(aggregate));
|
||||
bool contested = false;
|
||||
@@ -589,12 +85,13 @@ void contested_breeding_slots_go_to_the_same_parents() {
|
||||
continue;
|
||||
}
|
||||
++living;
|
||||
if (rule::breeds(member.age + 1, member.energy) &&
|
||||
member.matter >= rule::investment_matter) {
|
||||
if (rule.breeds(member.age + 1, member.energy) &&
|
||||
member.matter >= rule.investment_matter) {
|
||||
++eligible;
|
||||
}
|
||||
}
|
||||
const auto free_slots = individual.capacity > living ? individual.capacity - living : 0;
|
||||
const auto free_slots =
|
||||
individual.rule.capacity > living ? individual.rule.capacity - living : 0;
|
||||
if (eligible > free_slots && free_slots > 0) {
|
||||
contested = true;
|
||||
}
|
||||
@@ -610,7 +107,7 @@ void contested_breeding_slots_go_to_the_same_parents() {
|
||||
// allocation and is just the first control again with fewer members.
|
||||
CHECK(contested);
|
||||
CHECK(individual.census().births > 0);
|
||||
CHECK(individual.census().living == individual.capacity);
|
||||
CHECK(individual.census().living == individual.rule.capacity);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -626,15 +123,6 @@ struct Divergence {
|
||||
std::uint64_t energy_gap_per_thousand{};
|
||||
};
|
||||
|
||||
std::uint64_t gap_per_thousand(std::uint64_t left, std::uint64_t right) {
|
||||
const auto high = std::max(left, right);
|
||||
const auto low = std::min(left, right);
|
||||
if (high == 0) {
|
||||
return 0;
|
||||
}
|
||||
return (high - low) * 1000 / high;
|
||||
}
|
||||
|
||||
Divergence measure(std::uint64_t width, std::uint64_t ticks) {
|
||||
auto individual = founding_individuals(100);
|
||||
auto aggregate = founding_classes(individual, width);
|
||||
@@ -754,7 +242,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
|
||||
// Sized for the capacity rather than the founders: the population grows, and a
|
||||
// draw of more members than there were founders would otherwise run off the
|
||||
// end of the ledger and be reported as a stale plan.
|
||||
std::vector<Inventory> opening(first_member_store + rule::capacity);
|
||||
std::vector<Inventory> opening(first_member_store + rule.capacity);
|
||||
opening[escrow.value - 1] = spread(individual.environment, individual.matter_store);
|
||||
std::vector<ActiveMember> members;
|
||||
for (std::size_t index = 0; index < individual.members.size(); ++index) {
|
||||
@@ -776,7 +264,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
|
||||
gather.tick = Tick{0};
|
||||
gather.revision = 1;
|
||||
gather.destination = backing;
|
||||
for (std::uint64_t low = 0; low < rule::lifespan; low += 50) {
|
||||
for (std::uint64_t low = 0; low < rule.lifespan; low += 50) {
|
||||
gather.bounds.push_back({low, low + 50});
|
||||
}
|
||||
const auto folded = plan_collapse(members, gather);
|
||||
@@ -848,7 +336,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
|
||||
std::uint64_t drawn = 0;
|
||||
for (std::size_t index = 0; index < cohort.classes().size(); ++index) {
|
||||
const auto count = cohort.classes()[index].count;
|
||||
if (count == 0 || drawn + count > rule::capacity) {
|
||||
if (count == 0 || drawn + count > rule.capacity) {
|
||||
continue;
|
||||
}
|
||||
draws.push_back({index, count});
|
||||
|
||||
Reference in New Issue
Block a user