compare_res2_pairs()

int res2_comp::compare_res2_pairs ( res2_pair * f, res2_pair * g ) const

private

Definition at line 714 of file res-a0.cpp.

{
  // Lots of different orders appear here, controlled by the above
  // static variables.
  // if compare(f,g) returns -1, this says place g BEFORE f on the list.
  exponents_t EXP1, EXP2, EXP3, EXP4;
  int cmp, df, dg;
 
  if (compare_use_degree)
    {
      df = f->degree;
      dg = g->degree;
      if (df > dg) return -1;
      if (df < dg) return 1;
    }
 
  switch (compare_type)
    {
      case COMPARE_MONORDER:
        cmp = f->syz->comp->compare_num - g->syz->comp->compare_num;
        if (cmp < 0) return 1;
        if (cmp > 0)
          return -1;  // Lower compare num's should be on list earlier
        cmp = f->compare_num - g->compare_num;
        if (cmp < 0) return 1;
        if (cmp > 0) return -1;
        return 0;
      case COMPARE_LEX:
        EXP1 = ALLOCATE_EXPONENTS(exp_size);
        EXP2 = ALLOCATE_EXPONENTS(exp_size);
        M->to_expvector(f->syz->monom, EXP1);
        M->to_expvector(g->syz->monom, EXP2);
        if (compare_use_reverse)
          {
            for (int i = M->n_vars() - 1; i >= 0; i--)
              {
                if (EXP1[i] < EXP2[i]) return -compare_use_descending;
                if (EXP1[i] > EXP2[i]) return compare_use_descending;
              }
          }
        else
          {
            for (int i = 0; i < M->n_vars(); i++)
              {
                if (EXP1[i] < EXP2[i]) return -compare_use_descending;
                if (EXP1[i] > EXP2[i]) return compare_use_descending;
              }
          }
        [[fallthrough]];
      case COMPARE_ORDER:
        cmp = M->compare(f->syz->monom, g->syz->monom);
        if (cmp != 0) return compare_use_descending * cmp;
        cmp = f->syz->comp->compare_num - g->syz->comp->compare_num;
        if (cmp < 0) return -compare_use_descending;
        if (cmp > 0) return compare_use_descending;
        return 0;
      case COMPARE_LEX_EXTENDED:
        EXP1 = ALLOCATE_EXPONENTS(exp_size);
        EXP2 = ALLOCATE_EXPONENTS(exp_size);
        while (f->level >= 1)
          {
            M->to_expvector(f->syz->monom, EXP1);
            M->to_expvector(g->syz->monom, EXP2);
            if (compare_use_reverse)
              {
                for (int i = M->n_vars() - 1; i >= 0; i--)
                  {
                    if (EXP1[i] < EXP2[i]) return -compare_use_descending;
                    if (EXP1[i] > EXP2[i]) return compare_use_descending;
                  }
              }
            else
              {
                for (int i = 0; i < M->n_vars(); i++)
                  {
                    if (EXP1[i] < EXP2[i]) return -compare_use_descending;
                    if (EXP1[i] > EXP2[i]) return compare_use_descending;
                  }
              }
            // Go down one level
            f = f->syz->comp;
            g = g->syz->comp;
          }
        return 0;
      case COMPARE_LEX_EXTENDED2:
        EXP1 = ALLOCATE_EXPONENTS(exp_size);
        EXP2 = ALLOCATE_EXPONENTS(exp_size);
        EXP3 = ALLOCATE_EXPONENTS(exp_size);
        EXP4 = ALLOCATE_EXPONENTS(exp_size);
        M->to_expvector(f->syz->monom, EXP1);
        M->to_expvector(g->syz->monom, EXP2);
        if (compare_use_reverse)
          {
            for (int i = M->n_vars() - 1; i >= 0; i--)
              {
                if (EXP1[i] < EXP2[i]) return -compare_use_descending;
                if (EXP1[i] > EXP2[i]) return compare_use_descending;
              }
          }
        else
          {
            for (int i = 0; i < M->n_vars(); i++)
              {
                if (EXP1[i] < EXP2[i]) return -compare_use_descending;
                if (EXP1[i] > EXP2[i]) return compare_use_descending;
              }
          }
        while (f->level >= 1)
          {
            // Go down one level
            M->to_expvector(f->syz->monom, EXP1);
            M->to_expvector(g->syz->monom, EXP2);
            f = f->syz->comp;
            g = g->syz->comp;
            M->to_expvector(f->syz->monom, EXP3);
            M->to_expvector(g->syz->monom, EXP4);
            if (compare_use_reverse)
              {
                for (int i = M->n_vars() - 1; i >= 0; i--)
                  {
                    if (EXP1[i] - EXP3[i] < EXP2[i] - EXP4[i])
                      return -compare_use_descending;
                    if (EXP1[i] - EXP3[i] > EXP2[i] - EXP4[i])
                      return compare_use_descending;
                  }
              }
            else
              {
                for (int i = 0; i < M->n_vars(); i++)
                  {
                    if (EXP1[i] - EXP3[i] < EXP2[i] - EXP4[i])
                      return -compare_use_descending;
                    if (EXP1[i] - EXP3[i] > EXP2[i] - EXP4[i])
                      return compare_use_descending;
                  }
              }
          }
        return 0;
      default:
        return 0;
    }
}

References ALLOCATE_EXPONENTS, res2term::comp, COMPARE_LEX, COMPARE_LEX_EXTENDED, COMPARE_LEX_EXTENDED2, COMPARE_MONORDER, res2_pair::compare_num, COMPARE_ORDER, compare_type, compare_use_degree, compare_use_descending, compare_use_reverse, res2_pair::degree, exp_size, res2_pair::level, M, res2term::monom, and res2_pair::syz.

Referenced by merge_res2_pairs().