12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

formatting fixes

release/4.3a0
Varun Agrawal 2024-10-08 11:48:20 -04:00
parent 9f7ccbb33c
commit 8e85b68863
6 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gtsam/hybrid/HybridGaussianConditional.cpp
View File

@ -79,7 +79,7 @@ struct HybridGaussianConditional::Helper {
explicit Helper(const Conditionals &conditionals)
: conditionals(conditionals),
minNegLogConstant(std::numeric_limits<double>::infinity()) {
auto func = [this](const GC::shared_ptr& gc) -> GaussianFactorValuePair {
auto func = [this](const GC::shared_ptr &gc) -> GaussianFactorValuePair {
if (!gc) return {nullptr, std::numeric_limits<double>::infinity()};
if (!nrFrontals) nrFrontals = gc->nrFrontals();
double value = gc->negLogConstant();
@ -97,10 +97,10 @@ struct HybridGaussianConditional::Helper {
/* *******************************************************************************/
HybridGaussianConditional::HybridGaussianConditional(
const DiscreteKeys& discreteParents, const Helper& helper)
const DiscreteKeys &discreteParents, const Helper &helper)
: BaseFactor(discreteParents,
FactorValuePairs(helper.pairs,
[&](const GaussianFactorValuePair&
[&](const GaussianFactorValuePair &
pair) { // subtract minNegLogConstant
return GaussianFactorValuePair{
pair.first,
@ -225,7 +225,7 @@ KeyVector HybridGaussianConditional::continuousParents() const {
// remove that key from continuousParentKeys:
continuousParentKeys.erase(std::remove(continuousParentKeys.begin(),
continuousParentKeys.end(), key),
continuousParentKeys.end());
continuousParentKeys.end());
}
return continuousParentKeys;
}

2
gtsam/hybrid/HybridGaussianConditional.h
View File

@ -24,9 +24,9 @@
#include <gtsam/discrete/DecisionTree.h>
#include <gtsam/discrete/DecisionTreeFactor.h>
#include <gtsam/discrete/DiscreteKey.h>
#include <gtsam/hybrid/HybridGaussianProductFactor.h>
#include <gtsam/hybrid/HybridFactor.h>
#include <gtsam/hybrid/HybridGaussianFactor.h>
#include <gtsam/hybrid/HybridGaussianProductFactor.h>
#include <gtsam/inference/Conditional.h>
#include <gtsam/linear/GaussianConditional.h>

29
gtsam/hybrid/HybridGaussianFactor.cpp
View File

@ -93,27 +93,27 @@ struct HybridGaussianFactor::ConstructorHelper {
};
/* *******************************************************************************/
HybridGaussianFactor::HybridGaussianFactor(const ConstructorHelper &helper)
HybridGaussianFactor::HybridGaussianFactor(const ConstructorHelper& helper)
: Base(helper.continuousKeys, helper.discreteKeys),
factors_(helper.pairs) {}
HybridGaussianFactor::HybridGaussianFactor(
const DiscreteKey &discreteKey,
const std::vector<GaussianFactor::shared_ptr> &factors)
const DiscreteKey& discreteKey,
const std::vector<GaussianFactor::shared_ptr>& factors)
: HybridGaussianFactor(ConstructorHelper(discreteKey, factors)) {}
HybridGaussianFactor::HybridGaussianFactor(
const DiscreteKey &discreteKey,
const std::vector<GaussianFactorValuePair> &factorPairs)
const DiscreteKey& discreteKey,
const std::vector<GaussianFactorValuePair>& factorPairs)
: HybridGaussianFactor(ConstructorHelper(discreteKey, factorPairs)) {}
HybridGaussianFactor::HybridGaussianFactor(const DiscreteKeys &discreteKeys,
const FactorValuePairs &factors)
HybridGaussianFactor::HybridGaussianFactor(const DiscreteKeys& discreteKeys,
const FactorValuePairs& factors)
: HybridGaussianFactor(ConstructorHelper(discreteKeys, factors)) {}
/* *******************************************************************************/
bool HybridGaussianFactor::equals(const HybridFactor &lf, double tol) const {
const This *e = dynamic_cast<const This *>(&lf);
bool HybridGaussianFactor::equals(const HybridFactor& lf, double tol) const {
const This* e = dynamic_cast<const This*>(&lf);
if (e == nullptr) return false;
// This will return false if either factors_ is empty or e->factors_ is
@ -130,8 +130,8 @@ bool HybridGaussianFactor::equals(const HybridFactor &lf, double tol) const {
}
/* *******************************************************************************/
void HybridGaussianFactor::print(const std::string &s,
const KeyFormatter &formatter) const {
void HybridGaussianFactor::print(const std::string& s,
const KeyFormatter& formatter) const {
std::cout << (s.empty() ? "" : s + "\n");
HybridFactor::print("", formatter);
std::cout << "{\n";
@ -139,8 +139,7 @@ void HybridGaussianFactor::print(const std::string &s,
std::cout << " empty" << std::endl;
} else {
factors_.print(
"",
[&](Key k) { return formatter(k); },
"", [&](Key k) { return formatter(k); },
[&](const auto& pair) -> std::string {
RedirectCout rd;
std::cout << ":\n";
@ -158,7 +157,7 @@ void HybridGaussianFactor::print(const std::string &s,
/* *******************************************************************************/
GaussianFactorValuePair HybridGaussianFactor::operator()(
const DiscreteValues &assignment) const {
const DiscreteValues& assignment) const {
return factors_(assignment);
}
@ -176,7 +175,7 @@ HybridGaussianProductFactor HybridGaussianFactor::asProductFactor() const {
/* *******************************************************************************/
AlgebraicDecisionTree<Key> HybridGaussianFactor::errorTree(
const VectorValues &continuousValues) const {
const VectorValues& continuousValues) const {
// functor to convert from sharedFactor to double error value.
auto errorFunc = [&continuousValues](const auto& pair) {
return pair.first ? pair.first->error(continuousValues) + pair.second

17
gtsam/hybrid/HybridGaussianFactor.h
View File

@ -58,7 +58,7 @@ using GaussianFactorValuePair = std::pair<GaussianFactor::shared_ptr, double>;
* @ingroup hybrid
*/
class GTSAM_EXPORT HybridGaussianFactor : public HybridFactor {
public:
public:
using Base = HybridFactor;
using This = HybridGaussianFactor;
using shared_ptr = std::shared_ptr<This>;
@ -68,11 +68,11 @@ public:
/// typedef for Decision Tree of Gaussian factors and arbitrary value.
using FactorValuePairs = DecisionTree<Key, GaussianFactorValuePair>;
private:
private:
/// Decision tree of Gaussian factors indexed by discrete keys.
FactorValuePairs factors_;
public:
public:
/// @name Constructors
/// @{
@ -120,9 +120,8 @@ public:
bool equals(const HybridFactor &lf, double tol = 1e-9) const override;
void
print(const std::string &s = "",
const KeyFormatter &formatter = DefaultKeyFormatter) const override;
void print(const std::string &s = "", const KeyFormatter &formatter =
DefaultKeyFormatter) const override;
/// @}
/// @name Standard API
@ -138,8 +137,8 @@ public:
* @return AlgebraicDecisionTree<Key> A decision tree with the same keys
* as the factors involved, and leaf values as the error.
*/
AlgebraicDecisionTree<Key>
errorTree(const VectorValues &continuousValues) const override;
AlgebraicDecisionTree<Key> errorTree(
const VectorValues &continuousValues) const override;
/**
* @brief Compute the log-likelihood, including the log-normalizing constant.
@ -159,7 +158,7 @@ public:
/// @}
private:
private:
/**
* @brief Helper function to augment the [A|b] matrices in the factor
* components with the additional scalar values. This is done by storing the

38
gtsam/hybrid/HybridGaussianFactorGraph.cpp
View File

@ -24,6 +24,7 @@
#include <gtsam/discrete/DiscreteFactorGraph.h>
#include <gtsam/discrete/DiscreteJunctionTree.h>
#include <gtsam/discrete/DiscreteKey.h>
#include <gtsam/discrete/DiscreteValues.h>
#include <gtsam/hybrid/HybridConditional.h>
#include <gtsam/hybrid/HybridEliminationTree.h>
#include <gtsam/hybrid/HybridFactor.h>
@ -39,7 +40,6 @@
#include <gtsam/linear/GaussianJunctionTree.h>
#include <gtsam/linear/HessianFactor.h>
#include <gtsam/linear/JacobianFactor.h>
#include "gtsam/discrete/DiscreteValues.h"
#include <cstddef>
#include <iostream>
@ -63,9 +63,9 @@ static const VectorValues kEmpty;
/* ************************************************************************ */
// Throw a runtime exception for method specified in string s, and factor f:
static void throwRuntimeError(const std::string& s,
const std::shared_ptr<Factor>& f) {
auto& fr = *f;
static void throwRuntimeError(const std::string &s,
const std::shared_ptr<Factor> &f) {
auto &fr = *f;
throw std::runtime_error(s + " not implemented for factor type " +
demangle(typeid(fr).name()) + ".");
}
@ -83,11 +83,12 @@ static void printFactor(const std::shared_ptr<Factor> &factor,
const DiscreteValues &assignment,
const KeyFormatter &keyFormatter) {
if (auto hgf = dynamic_pointer_cast<HybridGaussianFactor>(factor)) {
if (assignment.empty())
if (assignment.empty()) {
hgf->print("HybridGaussianFactor:", keyFormatter);
else
} else {
hgf->operator()(assignment)
.first->print("HybridGaussianFactor, component:", keyFormatter);
}
} else if (auto gf = dynamic_pointer_cast<GaussianFactor>(factor)) {
factor->print("GaussianFactor:\n", keyFormatter);
@ -99,12 +100,13 @@ static void printFactor(const std::shared_ptr<Factor> &factor,
} else if (hc->isDiscrete()) {
factor->print("DiscreteConditional:\n", keyFormatter);
} else {
if (assignment.empty())
if (assignment.empty()) {
hc->print("HybridConditional:", keyFormatter);
else
} else {
hc->asHybrid()
->choose(assignment)
->print("HybridConditional, component:\n", keyFormatter);
}
}
} else {
factor->print("Unknown factor type\n", keyFormatter);
@ -112,13 +114,13 @@ static void printFactor(const std::shared_ptr<Factor> &factor,
}
/* ************************************************************************ */
void HybridGaussianFactorGraph::print(const std::string& s,
const KeyFormatter& keyFormatter) const {
void HybridGaussianFactorGraph::print(const std::string &s,
const KeyFormatter &keyFormatter) const {
std::cout << (s.empty() ? "" : s + " ") << std::endl;
std::cout << "size: " << size() << std::endl;
for (size_t i = 0; i < factors_.size(); i++) {
auto&& factor = factors_[i];
auto &&factor = factors_[i];
if (factor == nullptr) {
std::cout << "Factor " << i << ": nullptr\n";
continue;
@ -163,7 +165,7 @@ HybridGaussianProductFactor HybridGaussianFactorGraph::collectProductFactor()
const {
HybridGaussianProductFactor result;
for (auto& f : factors_) {
for (auto &f : factors_) {
// TODO(dellaert): can we make this cleaner and less error-prone?
if (auto orphan = dynamic_pointer_cast<OrphanWrapper>(f)) {
continue; // Ignore OrphanWrapper
@ -235,7 +237,7 @@ discreteElimination(const HybridGaussianFactorGraph &factors,
} else if (auto gmf = dynamic_pointer_cast<HybridGaussianFactor>(f)) {
// Case where we have a HybridGaussianFactor with no continuous keys.
// In this case, compute discrete probabilities.
auto potential = [&](const auto& pair) -> double {
auto potential = [&](const auto &pair) -> double {
auto [factor, scalar] = pair;
// If factor is null, it has been pruned, hence return potential zero
if (!factor) return 0.0;
@ -270,10 +272,10 @@ discreteElimination(const HybridGaussianFactorGraph &factors,
* depends on the discrete separator if present.
*/
static std::shared_ptr<Factor> createDiscreteFactor(
const ResultTree& eliminationResults,
const ResultTree &eliminationResults,
const DiscreteKeys &discreteSeparator) {
auto potential = [&](const auto &pair) -> double {
const auto& [conditional, factor] = pair.first;
const auto &[conditional, factor] = pair.first;
const double scalar = pair.second;
if (conditional && factor) {
// `error` has the following contributions:
@ -350,9 +352,9 @@ HybridGaussianFactorGraph::eliminate(const Ordering &keys) const {
// This is the elimination method on the leaf nodes
bool someContinuousLeft = false;
auto eliminate = [&](const std::pair<GaussianFactorGraph, double>& pair)
auto eliminate = [&](const std::pair<GaussianFactorGraph, double> &pair)
-> std::pair<Result, double> {
const auto& [graph, scalar] = pair;
const auto &[graph, scalar] = pair;
if (graph.empty()) {
return {{nullptr, nullptr}, 0.0};
@ -382,7 +384,7 @@ HybridGaussianFactorGraph::eliminate(const Ordering &keys) const {
// Create the HybridGaussianConditional from the conditionals
HybridGaussianConditional::Conditionals conditionals(
eliminationResults, [](const auto& pair) { return pair.first.first; });
eliminationResults, [](const auto &pair) { return pair.first.first; });
auto hybridGaussian = std::make_shared<HybridGaussianConditional>(
discreteSeparator, conditionals);

6
gtsam/hybrid/HybridGaussianFactorGraph.h
View File

@ -145,9 +145,9 @@ class GTSAM_EXPORT HybridGaussianFactorGraph
/// @name Testable
/// @{
void
print(const std::string &s = "HybridGaussianFactorGraph",
const KeyFormatter &keyFormatter = DefaultKeyFormatter) const override;
void print(
const std::string& s = "HybridGaussianFactorGraph",
const KeyFormatter& keyFormatter = DefaultKeyFormatter) const override;
/**
* @brief Print the errors of each factor in the hybrid factor graph.