gtsam  4.1.0
gtsam
PCGSolver.h
1 /* ----------------------------------------------------------------------------
2 
3  * GTSAM Copyright 2010, Georgia Tech Research Corporation,
4  * Atlanta, Georgia 30332-0415
5  * All Rights Reserved
6  * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
7 
8  * See LICENSE for the license information
9 
10  * -------------------------------------------------------------------------- */
11 
12 /*
13  * @file PCGSolver.h
14  * @brief Preconditioned Conjugate Gradient Solver for linear systems
15  * @date Jan 31, 2012
16  * @author Yong-Dian Jian
17  * @author Sungtae An
18  */
19 
20 #pragma once
21 
23 #include <string>
24 
25 namespace gtsam {
26 
27 class GaussianFactorGraph;
28 class KeyInfo;
29 class Preconditioner;
30 class VectorValues;
31 struct PreconditionerParameters;
32 
36 struct GTSAM_EXPORT PCGSolverParameters: public ConjugateGradientParameters {
37 public:
39  typedef boost::shared_ptr<PCGSolverParameters> shared_ptr;
40 
42  }
43 
44  void print(std::ostream &os) const override;
45 
46  /* interface to preconditioner parameters */
47  inline const PreconditionerParameters& preconditioner() const {
48  return *preconditioner_;
49  }
50 
51  // needed for python wrapper
52  void print(const std::string &s) const;
53 
54  boost::shared_ptr<PreconditionerParameters> preconditioner_;
55 
56  void setPreconditionerParams(const boost::shared_ptr<PreconditionerParameters> preconditioner);
57 };
58 
62 class GTSAM_EXPORT PCGSolver: public IterativeSolver {
63 public:
64  typedef IterativeSolver Base;
65  typedef boost::shared_ptr<PCGSolver> shared_ptr;
66 
67 protected:
68 
69  PCGSolverParameters parameters_;
70  boost::shared_ptr<Preconditioner> preconditioner_;
71 
72 public:
73  /* Interface to initialize a solver without a problem */
75  virtual ~PCGSolver() {
76  }
77 
78  using IterativeSolver::optimize;
79 
81  const KeyInfo &keyInfo, const std::map<Key, Vector> &lambda,
82  const VectorValues &initial) override;
83 
84 };
85 
89 class GTSAM_EXPORT GaussianFactorGraphSystem {
90 public:
91 
93  const Preconditioner &preconditioner, const KeyInfo &info,
94  const std::map<Key, Vector> &lambda);
95 
96  const GaussianFactorGraph &gfg_;
97  const Preconditioner &preconditioner_;
98  const KeyInfo &keyInfo_;
99  const std::map<Key, Vector> &lambda_;
100 
101  void residual(const Vector &x, Vector &r) const;
102  void multiply(const Vector &x, Vector& y) const;
103  void leftPrecondition(const Vector &x, Vector &y) const;
104  void rightPrecondition(const Vector &x, Vector &y) const;
105  inline void scal(const double alpha, Vector &x) const {
106  x *= alpha;
107  }
108  inline double dot(const Vector &x, const Vector &y) const {
109  return x.dot(y);
110  }
111  inline void axpy(const double alpha, const Vector &x, Vector &y) const {
112  y += alpha * x;
113  }
114 
115  void getb(Vector &b) const;
116 };
117 
120 
122 VectorValues buildVectorValues(const Vector &v, const Ordering &ordering,
123  const std::map<Key, size_t> & dimensions);
124 
126 VectorValues buildVectorValues(const Vector &v, const KeyInfo &keyInfo);
127 
129 
130 }
131 
gtsam::GaussianFactorGraph
A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e.
Definition: GaussianFactorGraph.h:68
gtsam::optimize
Point3 optimize(const NonlinearFactorGraph &graph, const Values &values, Key landmarkKey)
Optimize for triangulation.
Definition: triangulation.cpp:73
gtsam::Ordering
Definition: Ordering.h:34
gtsam::Preconditioner
Definition: Preconditioner.h:64
gtsam::PCGSolver
A virtual base class for the preconditioned conjugate gradient solver.
Definition: PCGSolver.h:62
gtsam::ConjugateGradientParameters
parameters for the conjugate gradient method
Definition: ConjugateGradientSolver.h:29
gtsam::axpy
void axpy(double alpha, const V1 &x, V2 &y)
BLAS Level 1 axpy: y <- alpha*x + y.
Definition: Vector.h:217
gtsam::IterativeOptimizationParameters
parameters for iterative linear solvers
Definition: IterativeSolver.h:44
gtsam::PreconditionerParameters
Definition: Preconditioner.h:24
ConjugateGradientSolver.h
Implementation of Conjugate Gradient solver for a linear system.
gtsam::buildVectorValues
VectorValues buildVectorValues(const Vector &v, const Ordering &ordering, const map< Key, size_t > &dimensions)
Create VectorValues from a Vector.
Definition: PCGSolver.cpp:140
gtsam::VectorValues
This class represents a collection of vector-valued variables associated each with a unique integer i...
Definition: VectorValues.h:74
gtsam
Global functions in a separate testing namespace.
Definition: chartTesting.h:28
gtsam::print
void print(const Matrix &A, const string &s, ostream &stream)
print without optional string, must specify cout yourself
Definition: Matrix.cpp:155
gtsam::IterativeSolver
Base class for Iterative Solvers like SubgraphSolver.
Definition: IterativeSolver.h:86
gtsam::PCGSolverParameters
Parameters for PCG.
Definition: PCGSolver.h:36
gtsam::KeyInfo
Handy data structure for iterative solvers.
Definition: IterativeSolver.h:126
gtsam::GaussianFactorGraphSystem
System class needed for calling preconditionedConjugateGradient.
Definition: PCGSolver.h:89
gtsam::scal
void scal(double alpha, Vector &x)
BLAS Level 1 scal: x <- alpha*x.
Definition: Vector.h:210
gtsam::dot
double dot(const V1 &a, const V2 &b)
Dot product.
Definition: Vector.h:194