mystical.unicat/monorepo - Change 4424H3BH5XHKE6A7JLV7YWAC3CNGCTVQJRKSKJ5FYID74LLDPS4AC

generic macro for operations

Created by GPeTJGuaAryfKVDHpJLoiRAiv9jDq5aAapfNcWjYu16v on August 25, 2023

4424H3BH5XHKE6A7JLV7YWAC3CNGCTVQJRKSKJ5FYID74LLDPS4AC

Dependencies

In channels

main

Change contents

Insertion in solver/test/algebra.c at line 4 [3.1755]

[3.1823]

[4.203]


static void assert_is_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  uint64_t eq = solver_Algebra_equals(a, lhs, rhs);
  if(solver_Algebra_to_boolean(a, eq) != solver_Algebra_boolean(a, true)) {
    printf("assert_is_equals\n");
    printf("lhs: ");
    solver_Algebra_show(a, lhs);
    printf("rhs: ");
    solver_Algebra_show(a, rhs);
    fprintf(stderr, "failed\n");
    exit(1);
  }
}

Insertion in solver/test/algebra.c at line 41 [3.1755]
[3.2067]
[3.2068]
Replacement in solver/test/algebra.c at line 43 [3.1755]
B:BD[3.2100] → [3.2100:2130]
```
  struct solver_Algebra a;
  
```
[3.2100]
[3.2130]
```
  struct solver_Algebra a; 
```

Insertion in solver/test/algebra.c at line 56 [3.1755]

[2.353]

[3.2372]


  solver_Algebra_free(&a); 
}
static void substitute(struct solver_Algebra *a, const char *input_, const char *needle_, const char *replacement_, const char *expected_) {
  uint64_t input = solver_Algebra_parse(a, input_); 
  uint64_t needle = solver_Algebra_parse(a, needle_); 
  uint64_t replacement = solver_Algebra_parse(a, replacement_); 
  uint64_t expected = solver_Algebra_parse(a, expected_); 
  uint64_t substituted = solver_Algebra_substitute(a, input, needle, replacement);
  assert_is_equals(a, substituted, expected);
}
static void test_substitute(void) {
  struct solver_Algebra a; 
  solver_Algebra_init(&a);

Insertion in solver/test/algebra.c at line 75 [3.1755]

[3.2373]

  substitute(&a, "10", "10", "20", "20");
  substitute(&a, "10", "15", "20", "10");
  substitute(&a, "x + y + z", "x", "y + y", "3 * y + z");

Insertion in solver/test/algebra.c at line 84 [3.1755]
[3.2454]
[2.354]
```
  test_substitute();
```
Insertion in solver/src/algebra.c at line 8 [3.2508]
[5.850]
[3.14101]
```
#include <alias/cpp.h>
```

Replacement in solver/src/algebra.c at line 38 [3.2508]

B:BD[3.34613] → [4.686:753]

static uint64_t get_car(struct solver_Algebra *a, uint64_t expr) {

[3.34613]

[4.753]

static uint64_t get_car(const struct solver_Algebra *a, uint64_t expr) {

Replacement in solver/src/algebra.c at line 42 [3.2508]

B:BD[3.35101] → [4.805:872]

static uint64_t get_cdr(struct solver_Algebra *a, uint64_t expr) {

[3.35101]

[4.872]

static uint64_t get_cdr(const struct solver_Algebra *a, uint64_t expr) {

Replacement in solver/src/algebra.c at line 46 [3.2508]

B:BD[3.36512] → [4.924:1009]

static uint64_t get_index(struct solver_Algebra *a, uint64_t expr, uint32_t index) {

[3.36512]

[4.1009]

static uint64_t get_index(const struct solver_Algebra *a, uint64_t expr, uint32_t index) {

Insertion in solver/src/algebra.c at line 61 [3.2508]

[5.962]

[4.1254]

// map : (item ⇒ item) ⇒ tree ⇒ tree
#define MAP_IMPL(NAME)                                                                                                       \
  static uint64_t NAME(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS));                         \
  static inline uint64_t NAME##__real(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {         \
    ALIAS_CPP_CAT(NAME, __REAL)                                                                                              \
  }                                                                                                                          \
  static inline uint64_t NAME##__variable(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {     \
    ALIAS_CPP_CAT(NAME, __VARIABLE)                                                                                          \
  }                                                                                                                          \
  static inline uint64_t NAME##__boolean(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {      \
    ALIAS_CPP_CAT(NAME, __BOOLEAN)                                                                                           \
  }                                                                                                                          \
  static inline uint64_t NAME##__undefined(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {    \
    ALIAS_CPP_CAT(NAME, __UNDEFINED)                                                                                         \
  }                                                                                                                          \
  static inline uint64_t NAME##__smallint(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {     \
    ALIAS_CPP_CAT(NAME, __SMALLINT)                                                                                          \
  }                                                                                                                          \
  static inline uint64_t NAME##__largeint(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {     \
    ALIAS_CPP_CAT(NAME, __LARGEINT)                                                                                          \
  }                                                                                                                          \
  static inline uint64_t NAME##__fraction(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {     \
    uint64_t in_numerator = get_car(a, expr);                                                                                \
    uint64_t in_denominator = get_cdr(a, expr);                                                                              \
    uint64_t numerator = NAME(a, in_numerator ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                            \
    uint64_t denominator = NAME(a, in_denominator ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                        \
    bool changed = in_numerator != numerator || in_denominator != denominator;                                               \
    ALIAS_CPP_CAT(NAME, __FRACTION)                                                                                          \
  }                                                                                                                          \
  static inline uint64_t NAME##__power(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {        \
    uint64_t in_base = get_car(a, expr);                                                                                     \
    uint64_t in_exponent = get_cdr(a, expr);                                                                                 \
    uint64_t base = NAME(a, in_base ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                      \
    uint64_t exponent = NAME(a, in_exponent ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                              \
    bool changed = in_base != base || in_exponent != exponent;                                                               \
    ALIAS_CPP_CAT(NAME, __POWER)                                                                                             \
  }                                                                                                                          \
  static inline uint64_t NAME##__sum(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {          \
    uint32_t count = get_list_count(expr);                                                                                   \
    const uint64_t *in_values = a->values.data + get_list_index(expr);                                                       \
    uint64_t *values = a->values.data + get_list_index(expr);                                                                \
    uint64_t mapped_value = 0;                                                                                               \
    uint32_t i__ = 0;                                                                                                        \
    for(;i__ < count; i__++) {                                                                                               \
      mapped_value = NAME(a, in_values[i__] ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                              \
      if(mapped_value != in_values[i__]) {                                                                                   \
        break;                                                                                                               \
      }                                                                                                                      \
    }                                                                                                                        \
    bool changed = i__ != count;                                                                                             \
    if(changed) {                                                                                                            \
      values = alias_stack_allocation(sizeof(*values) * count, alignof(*values));                                            \
      alias_memory_copy(values, sizeof(*values) * i__, in_values, sizeof(*values) * i__);                                    \
      values[i__++] = mapped_value;                                                                                          \
      for(;i__ < count; i__++) {                                                                                             \
        values[i__] = NAME(a, in_values[i__] ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                             \
      }                                                                                                                      \
    }                                                                                                                        \
    ALIAS_CPP_CAT(NAME, __SUM)                                                                                               \
  }                                                                                                                          \
  static inline uint64_t NAME##__product(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {      \
    uint32_t count = get_list_count(expr);                                                                                   \
    const uint64_t *in_values = a->values.data + get_list_index(expr);                                                       \
    uint64_t *values = a->values.data + get_list_index(expr);                                                                \
    uint64_t mapped_value = 0;                                                                                               \
    uint32_t i__ = 0;                                                                                                        \
    for(;i__ < count; i__++) {                                                                                               \
      mapped_value = NAME(a, in_values[i__] ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                              \
      if(mapped_value != in_values[i__]) {                                                                                   \
        break;                                                                                                               \
      }                                                                                                                      \
    }                                                                                                                        \
    bool changed = i__ != count;                                                                                             \
    if(changed) {                                                                                                            \
      values = alias_stack_allocation(sizeof(*values) * count, alignof(*values));                                            \
      alias_memory_copy(values, sizeof(*values) * i__, in_values, sizeof(*values) * i__);                                    \
      values[i__++] = mapped_value;                                                                                          \
      for(;i__ < count; i__++) {                                                                                             \
        values[i__] = NAME(a, in_values[i__] ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                             \
      }                                                                                                                      \
    }                                                                                                                        \
    ALIAS_CPP_CAT(NAME, __PRODUCT)                                                                                           \
  }                                                                                                                          \
  static inline uint64_t NAME##__equals(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {       \
    uint64_t in_lhs = get_car(a, expr);                                                                                      \
    uint64_t in_rhs = get_cdr(a, expr);                                                                                      \
    uint64_t lhs = NAME(a, in_lhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    uint64_t rhs = NAME(a, in_rhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    bool changed = in_lhs != lhs || in_rhs != rhs;                                                                           \
    ALIAS_CPP_CAT(NAME, __EQUALS)                                                                                            \
  }                                                                                                                          \
  static inline uint64_t NAME##__not_equals(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS))  {  \
    uint64_t in_lhs = get_car(a, expr);                                                                                      \
    uint64_t in_rhs = get_cdr(a, expr);                                                                                      \
    uint64_t lhs = NAME(a, in_lhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    uint64_t rhs = NAME(a, in_rhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    bool changed = in_lhs != lhs || in_rhs != rhs;                                                                           \
    ALIAS_CPP_CAT(NAME, __NOT_EQUALS)                                                                                        \
  }                                                                                                                          \
  static inline uint64_t NAME##__less_than(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS))  {   \
    uint64_t in_lhs = get_car(a, expr);                                                                                      \
    uint64_t in_rhs = get_cdr(a, expr);                                                                                      \
    uint64_t lhs = NAME(a, in_lhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    uint64_t rhs = NAME(a, in_rhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    bool changed = in_lhs != lhs || in_rhs != rhs;                                                                           \
    ALIAS_CPP_CAT(NAME, __LESS_THAN)                                                                                         \
  }                                                                                                                          \
  static inline uint64_t NAME##__greater_than(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) { \
    uint64_t in_lhs = get_car(a, expr);                                                                                      \
    uint64_t in_rhs = get_cdr(a, expr);                                                                                      \
    uint64_t lhs = NAME(a, in_lhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    uint64_t rhs = NAME(a, in_rhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    bool changed = in_lhs != lhs || in_rhs != rhs;                                                                           \
    ALIAS_CPP_CAT(NAME, __GREATER_THAN)                                                                                      \
  }                                                                                                                          \
  static inline uint64_t NAME##__invalid(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {      \
    ALIAS_CPP_CAT(NAME, __INVALID)                                                                                           \
  }                                                                                                                          \
  static uint64_t NAME(struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {                        \
    ALIAS_CPP_CAT(NAME, __FIRST_STATEMENT);                                                                                  \
    switch(get_tag(expr)) {                                                                                                  \
    case Tag_Real:                                                                                                           \
      return NAME##__real(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    case Tag_Variable:                                                                                                       \
      return NAME##__variable(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                    \
    case Tag_Boolean:                                                                                                        \
      return NAME##__boolean(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                     \
    case Tag_Undefined:                                                                                                      \
      return NAME##__undefined(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                   \
    case Tag_SmallInt:                                                                                                       \
      return NAME##__smallint(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                    \
    case Tag_LargeInt:                                                                                                       \
      return NAME##__largeint(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                    \
    case Tag_Fraction:                                                                                                       \
      return NAME##__fraction(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                    \
    case Tag_Power:                                                                                                          \
      return NAME##__power(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                       \
    case Tag_Sum:                                                                                                            \
      return NAME##__sum(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                         \
    case Tag_Product:                                                                                                        \
      return NAME##__product(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                     \
    case Tag_Equals:                                                                                                         \
      return NAME##__equals(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                      \
    case Tag_NotEquals:                                                                                                      \
      return NAME##__not_equals(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                  \
    case Tag_LessThan:                                                                                                       \
      return NAME##__less_than(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                   \
    case Tag_GreaterThan:                                                                                                    \
      return NAME##__greater_than(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                \
    default:                                                                                                                 \
      return NAME##__invalid(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                     \
    }                                                                                                                        \
  }
#define MAP(NAME) ALIAS_CPP_EVAL_3(MAP_IMPL(NAME))
// any : (item ⇒ bool) ⇒ tree ⇒ bool
#define ANY_IMPL(NAME)                                                                                                      \
  static bool NAME(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS));                      \
  static inline bool NAME##__real(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {      \
    ALIAS_CPP_CAT(NAME, __REAL)                                                                                             \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__variable(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {  \
    ALIAS_CPP_CAT(NAME, __VARIABLE)                                                                                         \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__boolean(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {   \
    ALIAS_CPP_CAT(NAME, __BOOLEAN)                                                                                          \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__undefined(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) { \
    ALIAS_CPP_CAT(NAME, __UNDEFINED)                                                                                        \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__smallint(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {  \
    ALIAS_CPP_CAT(NAME, __SMALLINT)                                                                                         \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__largeint(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {  \
    ALIAS_CPP_CAT(NAME, __LARGEINT)                                                                                         \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__fraction(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {  \
    uint64_t numerator = get_car(a, expr);                                                                                  \
    uint64_t denominator = get_cdr(a, expr);                                                                                \
    ALIAS_CPP_CAT(NAME, __FRACTION)                                                                                         \
    if(NAME(a, numerator ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                              \
      return true;                                                                                                          \
    }                                                                                                                       \
    if(NAME(a, denominator ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                            \
      return true;                                                                                                          \
    }                                                                                                                       \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__power(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {     \
    uint64_t base = get_car(a, expr);                                                                                       \
    uint64_t exponent = get_cdr(a, expr);                                                                                   \
    ALIAS_CPP_CAT(NAME, __POWER)                                                                                            \
    if(NAME(a, base ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                   \
      return true;                                                                                                          \
    }                                                                                                                       \
    if(NAME(a, exponent ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                               \
      return true;                                                                                                          \
    }                                                                                                                       \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__sum(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {       \
    uint32_t count = get_list_count(expr);                                                                                  \
    const uint64_t *values = a->values.data + get_list_index(expr);                                                         \
    ALIAS_CPP_CAT(NAME, __SUM)                                                                                              \
    for(uint32_t i = 0; i < count; i++) {                                                                                   \
      if(NAME(a, values[i] ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                            \
        return true;                                                                                                        \
			}                                                                                                                     \
    }                                                                                                                       \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__product(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {         \
    uint32_t count = get_list_count(expr);                                                                                  \
    const uint64_t *values = a->values.data + get_list_index(expr);                                                         \
    ALIAS_CPP_CAT(NAME, __PRODUCT)                                                                                          \
    for(uint32_t i = 0; i < count; i++) {                                                                                   \
      if(NAME(a, values[i] ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                            \
        return true;                                                                                                        \
			}                                                                                                                     \
    }                                                                                                                       \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__equals(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {       \
    uint64_t lhs = get_car(a, expr);                                                                                        \
    uint64_t rhs = get_cdr(a, expr);                                                                                        \
    ALIAS_CPP_CAT(NAME, __EQUALS)                                                                                           \
    if(NAME(a, lhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                    \
      return true;                                                                                                          \
    }                                                                                                                       \
    if(NAME(a, rhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                    \
      return true;                                                                                                          \
    }                                                                                                                       \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__not_equals(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS))  {  \
    uint64_t lhs = get_car(a, expr);                                                                                        \
    uint64_t rhs = get_cdr(a, expr);                                                                                        \
    ALIAS_CPP_CAT(NAME, __NOT_EQUALS)                                                                                       \
    if(NAME(a, lhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                    \
      return true;                                                                                                          \
    }                                                                                                                       \
    if(NAME(a, rhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                    \
      return true;                                                                                                          \
    }                                                                                                                       \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__less_than(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS))  {   \
    uint64_t lhs = get_car(a, expr);                                                                                        \
    uint64_t rhs = get_cdr(a, expr);                                                                                        \
    ALIAS_CPP_CAT(NAME, __LESS_THAN)                                                                                        \
    if(NAME(a, lhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                    \
      return true;                                                                                                          \
    }                                                                                                                       \
    if(NAME(a, rhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                    \
      return true;                                                                                                          \
    }                                                                                                                       \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__greater_than(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) { \
    uint64_t lhs = get_car(a, expr);                                                                                        \
    uint64_t rhs = get_cdr(a, expr);                                                                                        \
    ALIAS_CPP_CAT(NAME, __GREATER_THAN)                                                                                     \
    if(NAME(a, lhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                    \
      return true;                                                                                                          \
    }                                                                                                                       \
    if(NAME(a, rhs ALIAS_CPP_CAT(NAME, __EXTRA_PASS))) {                                                                    \
      return true;                                                                                                          \
    }                                                                                                                       \
    return false;                                                                                                           \
  }                                                                                                                         \
  static inline bool NAME##__invalid(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {   \
    ALIAS_CPP_CAT(NAME, __INVALID)                                                                                          \
    return false;                                                                                                           \
  }                                                                                                                         \
  static bool NAME(const struct solver_Algebra *a, uint64_t expr ALIAS_CPP_CAT(NAME, __EXTRA_PARAMS)) {                     \
    ALIAS_CPP_CAT(NAME, __FIRST_STATEMENT);                                                                                 \
    switch(get_tag(expr)) {                                                                                                 \
    case Tag_Real:                                                                                                          \
      return NAME##__real(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                       \
    case Tag_Variable:                                                                                                      \
      return NAME##__variable(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                   \
    case Tag_Boolean:                                                                                                       \
      return NAME##__boolean(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                    \
    case Tag_Undefined:                                                                                                     \
      return NAME##__undefined(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                  \
    case Tag_SmallInt:                                                                                                      \
      return NAME##__smallint(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                   \
    case Tag_LargeInt:                                                                                                      \
      return NAME##__largeint(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                   \
    case Tag_Fraction:                                                                                                      \
      return NAME##__fraction(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                   \
    case Tag_Power:                                                                                                         \
      return NAME##__power(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                      \
    case Tag_Sum:                                                                                                           \
      return NAME##__sum(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                        \
    case Tag_Product:                                                                                                       \
      return NAME##__product(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                    \
    case Tag_Equals:                                                                                                        \
      return NAME##__equals(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                     \
    case Tag_NotEquals:                                                                                                     \
      return NAME##__not_equals(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                 \
    case Tag_LessThan:                                                                                                      \
      return NAME##__less_than(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                  \
    case Tag_GreaterThan:                                                                                                   \
      return NAME##__greater_than(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                               \
    default:                                                                                                                \
      return NAME##__invalid(a, expr ALIAS_CPP_CAT(NAME, __EXTRA_PASS));                                                    \
    }                                                                                                                       \
  }
#define ANY(NAME) ALIAS_CPP_EVAL_3(ANY_IMPL(NAME))
// all      : (item ⇒ bool) ⇒ tree ⇒ bool
// all_pair : (item ⇒ item ⇒ bool) ⇒ tree ⇒ tree ⇒ bool
// each     : (item ⇒ void) ⇒ tree ⇒ void

Insertion in solver/src/algebra.c at line 387 [3.2508]
[4.1348]
[3.37657]
```
#include "algebra-substitute.inc"
#include "algebra-has.inc"
```
Insertion in solver/src/algebra.c at line 390 [3.2508]
[3.37658]
[5.963]
```
#undef MAP
#undef MAP_IMPL
#undef ANY
#undef ANY_IMPL
```

File addition: algebra-substitute.inc (----------)

[3.2472]

#define substitute__EXTRA_PARAMS , uint64_t search, uint64_t replace
#define substitute__EXTRA_PASS   , search, replace
#define substitute__FIRST_STATEMENT \
	do { \
		if(equals(a, expr, search)) { \
      return replace; \
		} \
	} while(0);
#define substitute__REAL         return expr;
#define substitute__VARIABLE     return expr;
#define substitute__BOOLEAN      return expr;
#define substitute__UNDEFINED    return expr;
#define substitute__SMALLINT     return expr;
#define substitute__LARGEINT     return expr;
#define substitute__FRACTION     return changed ? embed_fraction(a, numerator, denominator) : expr;
#define substitute__POWER        return changed ? embed_power(a, base, exponent) : expr;
#define substitute__SUM          return changed ? embed_sum(a, count, values) : expr;
#define substitute__PRODUCT      return changed ? embed_product(a, count, values) : expr;
#define substitute__EQUALS       return changed ? solver_Algebra_equals(a, lhs, rhs) : expr;
#define substitute__NOT_EQUALS   return changed ? solver_Algebra_not_equals(a, lhs, rhs) : expr;
#define substitute__LESS_THAN    return changed ? solver_Algebra_less_than(a, lhs, rhs) : expr;
#define substitute__GREATER_THAN return changed ? solver_Algebra_greater_than(a, lhs, rhs) : expr;
#define substitute__INVALID      return pack_undefined();
MAP(substitute)
uint64_t solver_Algebra_substitute(struct solver_Algebra *a, uint64_t expr, uint64_t search, uint64_t replace) {
  return substitute(a, expr, search, replace);
}

Insertion in solver/src/algebra-simplify.inc at line 4 [4.2790]

[4.2885]


#define simplify__EXTRA_PARAMS 
#define simplify__EXTRA_PASS   
#define simplify__FIRST_STATEMENT

Replacement in solver/src/algebra-simplify.inc at line 9 [4.2790]

B:BD[4.2886] → [2.1764:1868]

#define SIMPLIFY(TYPE, FN) static uint64_t simplify__##TYPE(struct solver_Algebra *a, uint64_t bits) FN

[4.2886]

[4.2989]

#define simplify__REAL         return expr;
#define simplify__VARIABLE     return expr;
#define simplify__BOOLEAN      return expr;
#define simplify__UNDEFINED    return expr;
#define simplify__SMALLINT     return expr;
#define simplify__LARGEINT     return expr;
#define simplify__FRACTION     return changed ? embed_fraction(a, numerator, denominator) : expr;
#define simplify__POWER        return changed ? embed_power(a, base, exponent) : expr;
#define simplify__SUM          return changed ? embed_sum(a, count, values) : expr;
#define simplify__PRODUCT      return changed ? embed_product(a, count, values) : expr;
#define simplify__EQUALS       return changed ? solver_Algebra_equals(a, lhs, rhs) : expr;
#define simplify__NOT_EQUALS   return changed ? solver_Algebra_not_equals(a, lhs, rhs) : expr;
#define simplify__LESS_THAN    return changed ? solver_Algebra_less_than(a, lhs, rhs) : expr;
#define simplify__GREATER_THAN return changed ? solver_Algebra_greater_than(a, lhs, rhs) : expr;
#define simplify__INVALID      return pack_undefined();
MAP(simplify)
uint64_t solver_Algebra_simplify(struct solver_Algebra *a, uint64_t expr) {
  return simplify(a, expr);
}
/*#define SIMPLIFY(TYPE, FN) static uint64_t simplify__##TYPE(struct solver_Algebra *a, uint64_t bits) FN

Insertion in solver/src/algebra-simplify.inc at line 127 [4.2790]
[4.5603]
```
*/
```

File addition: algebra-has.inc (----------)

[3.2472]

#define has__EXTRA_PARAMS , uint64_t search
#define has__EXTRA_PASS   ,          search
#define has__FIRST_STATEMENT \
	do { \
		if(equals(a, expr, search)) { \
      return true; \
		} \
	} while(0);
#define has__REAL         
#define has__VARIABLE     
#define has__BOOLEAN      
#define has__UNDEFINED    
#define has__SMALLINT     
#define has__LARGEINT     
#define has__FRACTION     
#define has__POWER        
#define has__SUM          
#define has__PRODUCT      
#define has__EQUALS       
#define has__NOT_EQUALS   
#define has__LESS_THAN    
#define has__GREATER_THAN 
#define has__INVALID      
ANY(has)
uint64_t solver_Algebra_has(struct solver_Algebra *a, uint64_t expr, uint64_t search) {
  return has(a, expr, search);
}

Replacement in solver/src/algebra-boolean.inc at line 1 [4.33929]

B:BD[4.33929] → [4.33930:34002]

static uint64_t boolean_not(struct solver_Algebra *a, uint64_t expr_) {

[4.33929]

[4.34002]

static uint64_t boolean_not(const struct solver_Algebra *a, uint64_t expr_) {

Replacement in solver/src/algebra-boolean.inc at line 7 [4.33929]

B:BD[4.34155] → [4.34155:34229]

static bool equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs);

[4.34155]

[5.4845]

static bool equals(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs);

Replacement in solver/src/algebra-boolean.inc at line 9 [4.33929]

B:BD[5.4846] → [2.13193:13280]

static bool equals__real__real(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.4846]

[5.4932]

static bool equals__real__real(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 13 [4.33929]

B:BD[5.4982] → [5.4982:5063]

static bool equals__real(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.4982]

[5.5063]

static bool equals__real(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 22 [4.33929]

B:BD[5.5184] → [2.13326:13421]

static bool equals__variable__variable(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.5184]

[5.5278]

static bool equals__variable__variable(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 26 [4.33929]

B:BD[4.34230] → [5.5350:5435]

static bool equals__variable(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.34230]

[5.5435]

static bool equals__variable(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 35 [4.33929]

B:BD[5.5568] → [2.13475:13568]

static bool equals__boolean__boolean(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.5568]

[5.5660]

static bool equals__boolean__boolean(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 39 [4.33929]

B:BD[5.5716] → [5.5716:5800]

static bool equals__boolean(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.5716]

[5.5800]

static bool equals__boolean(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 48 [4.33929]

B:BD[5.5930] → [2.13620:13717]

static bool equals__undefined__undefined(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.5930]

[5.6026]

static bool equals__undefined__undefined(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 54 [4.33929]

B:BD[5.6094] → [5.6094:6180]

static bool equals__undefined(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.6094]

[5.6180]

static bool equals__undefined(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 63 [4.33929]

B:BD[5.6316] → [2.13773:13868]

static bool equals__smallint__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.6316]

[2.13868]

static bool equals__smallint__smallint(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 67 [4.33929]

B:BD[5.6464] → [2.13924:14009]

static bool equals__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.6464]

[5.6548]

static bool equals__smallint(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 75 [4.33929]

B:BD[5.6677] → [2.14084:14280]

static bool equals__largeint__largeint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { return false; }
static bool equals__largeint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.6677]

[5.6881]

static bool equals__largeint__largeint(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { return false; }
static bool equals__largeint(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 85 [4.33929]

B:BD[5.7022] → [2.14355:14466]

∅:D[2.14466] → [5.7132:7217]

B:BD[5.7132] → [5.7132:7217]

static bool equals__fraction__fraction(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { return false; }
static bool equals__fraction(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.7022]

[5.7217]

static bool equals__fraction__fraction(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { return false; }
static bool equals__fraction(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 95 [4.33929]

B:BD[5.7350] → [2.14520:14609]

static bool equals__power__power(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.7350]

[5.7438]

static bool equals__power__power(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 99 [4.33929]

B:BD[5.7542] → [5.7542:7624]

static bool equals__power(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.7542]

[5.7624]

static bool equals__power(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 108 [4.33929]

B:BD[5.7748] → [2.14657:14742]

static bool equals__sum__sum(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.7748]

[5.7832]

static bool equals__sum__sum(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 121 [4.33929]

B:BD[5.8084] → [5.8084:8164]

static bool equals__sum(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.8084]

[5.8164]

static bool equals__sum(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 130 [4.33929]

B:BD[5.8282] → [2.14786:14879]

static bool equals__product__product(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[5.8282]

[5.8374]

static bool equals__product__product(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 143 [4.33929]

B:BD[4.34591] → [5.8624:8708]

static bool equals__product(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.34591]

[5.8708]

static bool equals__product(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 152 [4.33929]

B:BD[4.34787] → [2.14931:15022]

static bool equals__equals__equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.34787]

[2.15022]

static bool equals__equals__equals(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 157 [4.33929]

B:BD[4.34788] → [5.9032:9115]

static bool equals__equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.34788]

[5.9115]

static bool equals__equals(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 166 [4.33929]

B:BD[4.35150] → [2.15182:15281]

static bool equals__not_equals__not_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.35150]

[5.9340]

static bool equals__not_equals__not_equals(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 170 [4.33929]

B:BD[4.35244] → [5.9444:9531]

static bool equals__not_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.35244]

[5.9531]

static bool equals__not_equals(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 179 [4.33929]

B:BD[4.35251] → [2.15339:15436]

static bool equals__less_than__less_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.35251]

[5.9765]

static bool equals__less_than__less_than(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 183 [4.33929]

B:BD[4.35726] → [5.9869:9955]

static bool equals__less_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.35726]

[5.9955]

static bool equals__less_than(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 192 [4.33929]

B:BD[4.35796] → [2.15492:15595]

static bool equals__greater_than__greater_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.35796]

[5.10192]

static bool equals__greater_than__greater_than(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 196 [4.33929]

B:BD[4.36083] → [5.10296:10385]

static bool equals__greater_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.36083]

[5.10385]

static bool equals__greater_than(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Replacement in solver/src/algebra-boolean.inc at line 205 [4.33929]

B:BD[4.36091] → [4.36091:36166]

static bool equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

[4.36091]

[4.36166]

static bool equals(const struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

Insertion in solver/include/solver/algebra.h at line 65 [3.38518]

[3.40986]


uint64_t solver_Algebra_substitute(struct solver_Algebra *a, uint64_t expr, uint64_t search, uint64_t replace);

Insertion in solver/include/solver/algebra.h at line 68 [3.38518]

[3.40987]

uint64_t solver_Algebra_has(struct solver_Algebra *a, uint64_t expr, uint64_t search);