Search for k-best in factor graph

[dellaert]

This PR builds upon #2005, now enabling constructing a DiscreteSearch instance from a factor graph. This avoids having to do costly inference to transform into a Bayes net or Bayes tree. There are two versions:

• one that groups factors using an elimination tree, one per variable in the given ordering
• one that additionally groups the factors according to cliques, multi-frontal style

There is still a bit of compute that happens in the constructor: factors get multiplied together for each "search slot". So, this does the "product" of "sum-product", but not the sum, not the division to get a conditional.

The choice between e-tree or j-tree is documented:

  /**
   * Construct from a DiscreteFactorGraph.
   *
   * Internally creates either an elimination tree or a junction tree. The
   * latter incurs more up-front computation but the search itself might be
   * faster. Then again, for the elimination tree, the heuristic will be more
   * fine-grained (more slots).
   *
   * @param factorGraph The factor graph to search over.
   * @param ordering The ordering used to create etree (and maybe jtree).
   * @param buildJunctionTree Whether to build a junction tree or not.
   */
  static DiscreteSearch FromFactorGraph(const DiscreteFactorGraph& factorGraph,
                                        const Ordering& ordering,
                                        bool buildJunctionTree = false);

Testing:

All unit tests pass, and all variants give the same answer for Asia, for both MPE and 4-best solutions:

  auto fromETree =
      DiscreteSearch::FromFactorGraph(asia::factorGraph, asia::ordering);
  auto fromJunctionTree =
      DiscreteSearch::FromFactorGraph(asia::factorGraph, asia::ordering, true);
  const DiscreteSearch fromBayesNet(asia::bayesNet);
  const DiscreteSearch fromBayesTree(asia::bayesTree);

  for (auto& search :
       {fromETree, fromJunctionTree, fromBayesNet, fromBayesTree}) {
    // Ask for the MPE
    auto mpe = search.run();

    EXPECT_LONGS_EQUAL(1, mpe.size());
    // Regression test: check the MPE solution
    EXPECT_DOUBLES_EQUAL(1.236627, std::fabs(mpe[0].error), 1e-5);

    // Check it is equal to MPE via inference
    EXPECT(assert_equal(asia::mpe, mpe[0].assignment));

    // Ask for top 4 solutions
    auto solutions = search.run(4);

    EXPECT_LONGS_EQUAL(4, solutions.size());
    // Regression test: check the first and last solution
    EXPECT_DOUBLES_EQUAL(1.236627, std::fabs(solutions[0].error), 1e-5);
    EXPECT_DOUBLES_EQUAL(2.201708, std::fabs(solutions[3].error), 1e-5);
  }

[varunagrawal]

LGTM modulo some minor comments.