screen_map.c
philosophy/screen_map.c · 308 line(s) · c
#include "screen_map.h"
#include <math.h>
#include <string.h>
static bool sm_valid_domain(sm_domain domain) {
return (unsigned)domain < (unsigned)SM_DOMAIN_COUNT;
}
static bool sm_valid_source(sm_source source) {
return (unsigned)source < (unsigned)SM_SOURCE_COUNT;
}
static bool sm_copy_text(char *destination, size_t capacity,
const char *source, bool allow_empty) {
size_t length;
if (destination == NULL || source == NULL || capacity == 0u) {
return false;
}
length = strlen(source);
if ((!allow_empty && length == 0u) || length >= capacity) {
return false;
}
memcpy(destination, source, length + 1u);
return true;
}
static bool sm_observation_is_valid(const sm_observation *observation) {
if (observation == NULL) {
return false;
}
if (memchr(observation->key, '\0', sizeof(observation->key)) == NULL ||
observation->key[0] == '\0' ||
memchr(observation->unit, '\0', sizeof(observation->unit)) == NULL) {
return false;
}
if (!isfinite(observation->value) ||
!isfinite(observation->confidence) ||
observation->confidence < 0.0 ||
observation->confidence > 1.0) {
return false;
}
if (!sm_valid_domain(observation->domain) ||
!sm_valid_source(observation->source)) {
return false;
}
if (observation->source == SM_SOURCE_ANIMAL_MODEL &&
observation->domain != SM_DOMAIN_EVIDENCE) {
return false;
}
return true;
}
sm_status sm_observation_init(
sm_observation *out, const char *key, const char *unit,
double value, uint64_t observed_at_epoch_seconds,
sm_domain domain, sm_source source, double confidence,
uint32_t relationship_group, bool share_with_conversation) {
sm_observation candidate;
if (out == NULL || key == NULL || unit == NULL ||
!sm_valid_domain(domain) || !sm_valid_source(source)) {
return SM_STATUS_INVALID_ARGUMENT;
}
if (!isfinite(value) || !isfinite(confidence) ||
confidence < 0.0 || confidence > 1.0) {
return SM_STATUS_INVALID_NUMBER;
}
if (source == SM_SOURCE_ANIMAL_MODEL && domain != SM_DOMAIN_EVIDENCE) {
return SM_STATUS_INVALID_ARGUMENT;
}
memset(&candidate, 0, sizeof(candidate));
if (!sm_copy_text(candidate.key, sizeof(candidate.key), key, false) ||
!sm_copy_text(candidate.unit, sizeof(candidate.unit), unit, true)) {
return SM_STATUS_INVALID_ARGUMENT;
}
candidate.value = value;
candidate.observed_at_epoch_seconds = observed_at_epoch_seconds;
candidate.confidence = confidence;
candidate.relationship_group = relationship_group;
candidate.domain = domain;
candidate.source = source;
candidate.share_with_conversation = share_with_conversation;
*out = candidate;
return SM_STATUS_OK;
}
void sm_profile_init(sm_profile *profile) {
if (profile != NULL) {
memset(profile, 0, sizeof(*profile));
}
}
sm_status sm_profile_add(sm_profile *profile, const sm_observation *observation) {
size_t index;
if (profile == NULL || !sm_observation_is_valid(observation)) {
return SM_STATUS_INVALID_ARGUMENT;
}
if (profile->count > SM_MAX_OBSERVATIONS) {
return SM_STATUS_INVALID_ARGUMENT;
}
if (profile->count == SM_MAX_OBSERVATIONS) {
return SM_STATUS_CAPACITY_EXCEEDED;
}
for (index = 0u; index < profile->count; ++index) {
const sm_observation *existing = &profile->observations[index];
if (existing->observed_at_epoch_seconds ==
observation->observed_at_epoch_seconds &&
strcmp(existing->key, observation->key) == 0) {
return SM_STATUS_INVALID_ARGUMENT;
}
}
profile->observations[profile->count] = *observation;
++profile->count;
return SM_STATUS_OK;
}
sm_status sm_observation_delta(
const sm_observation *earlier,
const sm_observation *later,
double *delta_out) {
double delta;
if (delta_out == NULL ||
!sm_observation_is_valid(earlier) ||
!sm_observation_is_valid(later)) {
return SM_STATUS_INVALID_ARGUMENT;
}
if (strcmp(earlier->key, later->key) != 0 ||
strcmp(earlier->unit, later->unit) != 0 ||
earlier->domain != later->domain ||
later->observed_at_epoch_seconds <=
earlier->observed_at_epoch_seconds) {
return SM_STATUS_INCOMPATIBLE_OBSERVATIONS;
}
delta = later->value - earlier->value;
if (!isfinite(delta)) {
return SM_STATUS_INVALID_NUMBER;
}
*delta_out = delta;
return SM_STATUS_OK;
}
sm_status sm_screen_map_build(
const sm_profile *profile,
uint32_t allowed_domain_mask,
sm_screen_map *map_out) {
size_t index;
if (profile == NULL || map_out == NULL ||
profile->count > SM_MAX_OBSERVATIONS) {
return SM_STATUS_INVALID_ARGUMENT;
}
memset(map_out, 0, sizeof(*map_out));
map_out->unknowns_left_unknown = true;
for (index = 0u; index < profile->count; ++index) {
const sm_observation *observation = &profile->observations[index];
if (!sm_observation_is_valid(observation)) {
return SM_STATUS_INVALID_ARGUMENT;
}
if (!observation->share_with_conversation) {
++map_out->omitted_private;
continue;
}
if (allowed_domain_mask != 0u &&
(allowed_domain_mask & SM_DOMAIN_BIT(observation->domain)) == 0u) {
++map_out->omitted_by_domain;
continue;
}
map_out->observations[map_out->count] = *observation;
++map_out->count;
}
return SM_STATUS_OK;
}
sm_status sm_reduce_integer(
double raw_value, int minimum, int maximum,
sm_rounding rounding, sm_reduction *out) {
double rounded;
if (out == NULL) {
return SM_STATUS_INVALID_ARGUMENT;
}
out->value = 0;
out->valid = false;
out->was_clamped = false;
if (!isfinite(raw_value)) {
return SM_STATUS_INVALID_NUMBER;
}
if (minimum > maximum ||
(unsigned)rounding > (unsigned)SM_ROUND_TRUNCATE) {
return SM_STATUS_INVALID_RANGE;
}
if (raw_value < (double)minimum) {
out->value = minimum;
out->valid = true;
out->was_clamped = true;
return SM_STATUS_OK;
}
if (raw_value > (double)maximum) {
out->value = maximum;
out->valid = true;
out->was_clamped = true;
return SM_STATUS_OK;
}
switch (rounding) {
case SM_ROUND_NEAREST_TIES_AWAY_FROM_ZERO:
rounded = raw_value >= 0.0
? floor(raw_value + 0.5)
: ceil(raw_value - 0.5);
break;
case SM_ROUND_FLOOR: rounded = floor(raw_value); break;
case SM_ROUND_CEIL: rounded = ceil(raw_value); break;
case SM_ROUND_TRUNCATE: rounded = trunc(raw_value); break;
default: return SM_STATUS_INVALID_RANGE;
}
if (rounded < (double)minimum) {
rounded = (double)minimum;
out->was_clamped = true;
} else if (rounded > (double)maximum) {
rounded = (double)maximum;
out->was_clamped = true;
}
out->value = (int)rounded;
out->valid = true;
return SM_STATUS_OK;
}
sm_status sm_reduce_ratio(
double numerator, double denominator, double scale,
int minimum, int maximum, sm_rounding rounding,
sm_reduction *out) {
double ratio;
if (out == NULL) {
return SM_STATUS_INVALID_ARGUMENT;
}
out->value = 0;
out->valid = false;
out->was_clamped = false;
if (!isfinite(numerator) || !isfinite(denominator) ||
!isfinite(scale) || denominator == 0.0) {
return SM_STATUS_INVALID_NUMBER;
}
ratio = (numerator / denominator) * scale;
if (!isfinite(ratio)) {
return SM_STATUS_INVALID_NUMBER;
}
return sm_reduce_integer(ratio, minimum, maximum, rounding, out);
}
const char *sm_status_string(sm_status status) {
switch (status) {
case SM_STATUS_OK: return "ok";
case SM_STATUS_INVALID_ARGUMENT: return "invalid argument";
case SM_STATUS_INVALID_NUMBER: return "invalid number";
case SM_STATUS_INVALID_RANGE: return "invalid range";
case SM_STATUS_INCOMPATIBLE_OBSERVATIONS: return "incompatible observations";
case SM_STATUS_CAPACITY_EXCEEDED: return "capacity exceeded";
case SM_STATUS_NOT_FOUND: return "not found";
default: return "unknown status";
}
}
const char *sm_domain_string(sm_domain domain) {
switch (domain) {
case SM_DOMAIN_CONTEXT: return "context";
case SM_DOMAIN_LEARNING: return "learning";
case SM_DOMAIN_SKILL: return "skill";
case SM_DOMAIN_WELLBEING: return "wellbeing";
case SM_DOMAIN_BIOLOGY: return "biology";
case SM_DOMAIN_HEALTH: return "health";
case SM_DOMAIN_MOTOR_TASK: return "motor-task";
case SM_DOMAIN_RELATIONSHIP: return "relationship";
case SM_DOMAIN_EVIDENCE: return "research-evidence";
default: return "unknown";
}
}
const char *sm_source_string(sm_source source) {
switch (source) {
case SM_SOURCE_SELF_REPORT: return "self-report";
case SM_SOURCE_DIRECT_OBSERVATION: return "direct-observation";
case SM_SOURCE_STANDARDIZED_INSTRUMENT: return "standardized-instrument";
case SM_SOURCE_QUALIFIED_PROFESSIONAL: return "qualified-professional";
case SM_SOURCE_PEER_REVIEWED_RESEARCH: return "peer-reviewed-research";
case SM_SOURCE_ANIMAL_MODEL: return "animal-model";
default: return "unknown";
}
}