traits More...

Namespaces
	detail

	dynamics

	example

	examples

	gtsfm

	imuBias
	All bias models live in the imuBias namespace.

	inference

	initialize

	internal

	lago

	linear

	noiseModel
	All noise models live in the noiseModel namespace.

	partition

	simulated3D

	so3

	symbol_shorthand

	testing

	tiny

	traits

	treeTraversal

	utilities

	utils

Classes
struct	_ValuesConstKeyValuePair

struct	_ValuesKeyValuePair

class	AcceleratedPowerMethod
	Compute maximum Eigenpair with accelerated power method. More...

class	AcceleratingScenario
	Accelerating from an arbitrary initial state, with optional rotation. More...

class	ActiveSetSolver

class	AdaptAutoDiff

struct	additive_group_tag

class	AHRS

class	AHRSFactor

class	AlgebraicDecisionTree

class	AllDiff

class	AntiFactor

class	Assignment

class	AttitudeFactor
	Base class for an attitude factor that constrains the rotation between body and navigation frames. More...

class	BarometricFactor

class	Basis

class	BatchFixedLagSmoother

class	BayesNet

class	BayesTree

class	BayesTreeCliqueBase

struct	BayesTreeCliqueData

struct	BayesTreeCliqueStats

class	BayesTreeOrphanWrapper

class	BayesTreeOrphanWrapper< HybridBayesTreeClique >
	Class for Hybrid Bayes tree orphan subtrees. More...

struct	Bearing

struct	Bearing< Pose2, T >

struct	Bearing< Pose3, Point3 >

struct	Bearing< Pose3, Pose3 >

struct	BearingFactor

struct	BearingRange

class	BearingRangeFactor

class	BearingS2

class	BetweenConstraint

class	BetweenFactor

class	BetweenFactorEM

class	BiasedGPSFactor

class	BilinearAngleTranslationFactor

class	BinaryAllDiff

struct	BinaryJacobianFactor

class	BinaryMeasurement

class	BinarySumExpression

class	BlockJacobiPreconditioner

struct	BlockJacobiPreconditionerParameters

struct	BoundingConstraint1

struct	BoundingConstraint2

class	BTree
	Binary tree. More...

class	Cal3
	Common base class for all calibration models. More...

class	Cal3_S2
	The most common 5DOF 3D->2D calibration. More...

class	Cal3_S2Stereo
	The most common 5DOF 3D->2D calibration, stereo version. More...

class	Cal3Bundler
	Calibration used by Bundler. More...

struct	Cal3Bundler0

class	Cal3DS2
	Calibration of a camera with radial distortion that also supports Lie-group behaviors for optimization. More...

class	Cal3DS2_Base
	Calibration of a camera with radial distortion. More...

class	Cal3f
	Calibration model with a single focal length and zero skew. More...

class	Cal3Fisheye
	Calibration of a fisheye camera. More...

class	Cal3Unified
	Calibration of a omni-directional camera with mirror + lens radial distortion. More...

class	CalibratedCamera

class	CameraSet
	A set of cameras, all with their own calibration. More...

struct	CGState

struct	Chebyshev1Basis

class	Chebyshev2

struct	Chebyshev2Basis

class	CheiralityException

class	CholeskyFailed
	Indicate Cholesky factorization failure. More...

class	ClusterTree

class	CombinedImuFactor

class	CombinedScenarioRunner

class	ComponentDerivativeFactor

class	compose_key_visitor

class	ConcurrentBatchFilter

class	ConcurrentBatchSmoother

class	ConcurrentFilter

class	ConcurrentIncrementalFilter

class	ConcurrentIncrementalSmoother

class	ConcurrentMap

class	ConcurrentSmoother

class	Conditional

struct	ConjugateGradientParameters

struct	const_selector

struct	const_selector< BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST >

struct	const_selector< const BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST >

class	ConstantTwistScenario

class	ConstantVelocityFactor

class	Constraint

struct	ConstructorTraversalData

class	CSP

class	CustomFactor

class	Cyclic
	Cyclic group of order N. More...

class	DecisionTree
	a decision tree is a function from assignments to values. More...

class	DecisionTreeFactor

class	DeltaFactor

class	DeltaFactorBase

struct	DeltaImpl

class	DerivativeFactor

struct	DGroundConstraint

struct	DHeightPrior

class	DirectProduct

class	DirectSum

class	DiscreteBayesNet

class	DiscreteBayesTree
	A Bayes tree representing a Discrete distribution. More...

class	DiscreteBayesTreeClique

class	DiscreteConditional

class	DiscreteDistribution

class	DiscreteEliminationTree
	Elimination tree for discrete factors. More...

class	DiscreteEulerPoincareHelicopter

class	DiscreteFactor

class	DiscreteFactorGraph

class	DiscreteJunctionTree

struct	DiscreteKeys
	DiscreteKeys is a set of keys that can be assembled using the & operator. More...

class	DiscreteLookupDAG

class	DiscreteLookupTable
	DiscreteLookupTable table for max-product. More...

class	DiscreteMarginals

class	DiscreteValues

class	DoglegOptimizer

struct	DoglegOptimizerImpl

class	DoglegParams

class	Domain

struct	DotWriter
	DotWriter is a helper class for writing graphviz .dot files. More...

struct	DRollPrior

class	DSF

class	DSFBase

class	DSFMap

class	DSFVector

struct	Dummy

class	DummyFactor

class	DummyPreconditioner

struct	DummyPreconditionerParameters

class	DynamicValuesMismatched

class	EdgeKey

class	EliminatableClusterTree

class	EliminateableFactorGraph

struct	EliminationData

struct	EliminationTraits

struct	EliminationTraits< DiscreteFactorGraph >

struct	EliminationTraits< GaussianFactorGraph >

struct	EliminationTraits< HybridGaussianFactorGraph >

struct	EliminationTraits< SymbolicFactorGraph >

class	EliminationTree

class	EmptyCal

class	EqualityFactorGraph

struct	equals

struct	equals_star

struct	equalsVector

class	EquivInertialNavFactor_GlobalVel

class	EquivInertialNavFactor_GlobalVel_NoBias

class	EssentialMatrix

class	EssentialMatrixConstraint

class	EssentialMatrixFactor

class	EssentialMatrixFactor2

class	EssentialMatrixFactor3

class	EssentialMatrixFactor4

class	EssentialTransferFactor
	Transfers points between views using essential matrices with a shared calibration. More...

class	EssentialTransferFactorK
	Transfers points between views using essential matrices, optimizes for calibrations of the views, as well. Note that the EssentialMatrixFactor4 does something similar but without transfer. More...

class	EvaluationFactor
	Factor for enforcing the scalar value of the polynomial BASIS representation at `x` is the same as the measurement `z` when using a pseudo-spectral parameterization. More...

class	Event

class	Expression

class	ExpressionFactor

class	ExpressionFactorGraph

class	ExpressionFactorN

class	ExtendedKalmanFilter

class	Factor

class	FactorGraph

class	FastList

class	FastMap

class	FastSet

class	FitBasis

struct	FixedDimension
	Give fixed size dimension of a type, fails at compile time if dynamic. More...

class	FixedLagSmoother

class	FixedLagSmootherKeyTimestampMap

class	FixedVector

class	FourierBasis
	Fourier basis. More...

class	FrobeniusBetweenFactor

class	FrobeniusFactor

class	FrobeniusPrior

class	FullIMUFactor

class	FunctorizedFactor

class	FunctorizedFactor2

class	FundamentalMatrix
	Represents a fundamental matrix in computer vision, which encodes the epipolar geometry between two views. More...

class	G_x1

class	GaussianBayesNet

class	GaussianBayesTree

class	GaussianBayesTreeClique

class	GaussianConditional

class	GaussianDensity

class	GaussianEliminationTree

class	GaussianFactor

class	GaussianFactorGraph

class	GaussianFactorGraphSystem

class	GaussianISAM

class	GaussianJunctionTree

class	GaussMarkov1stOrderFactor

class	GaussNewtonOptimizer

class	GaussNewtonParams

class	GeneralSFMFactor

class	GeneralSFMFactor2

class	GenericProjectionFactor

class	GenericStereoFactor

class	GenericValue

class	GncOptimizer

class	GncParams

class	GPSFactor

class	GPSFactor2

struct	GraphvizFormatting

struct	group_tag
	tag to assert a type is a group More...

struct	HasBearing

struct	HasRange

struct	HasTestablePrereqs
	Requirements on type to pass it to Testable template below. More...

class	HessianFactor
	A Gaussian factor using the canonical parameters (information form) More...

struct	HybridAssignmentData
	Helper class for Depth First Forest traversal on the HybridBayesTree. More...

class	HybridBayesNet

class	HybridBayesTree

class	HybridBayesTreeClique
	A clique in a HybridBayesTree which is a HybridConditional internally. More...

class	HybridConditional

struct	HybridConstructorTraversalData

class	HybridEliminationTree

class	HybridFactor

class	HybridFactorGraph

class	HybridGaussianConditional
	A conditional of gaussian conditionals indexed by discrete variables, as part of a Bayes Network. This is the result of the elimination of a continuous variable in a hybrid scheme, such that the remaining variables are discrete+continuous. More...

class	HybridGaussianFactor
	Implementation of a discrete-conditioned hybrid factor. Implements a joint discrete-continuous factor where the discrete variable serves to "select" a component corresponding to a GaussianFactor. More...

class	HybridGaussianFactorGraph

class	HybridGaussianISAM
	Incremental Smoothing and Mapping (ISAM) algorithm for hybrid factor graphs. More...

class	HybridGaussianProductFactor
	Alias for DecisionTree of GaussianFactorGraphs and their scalar sums. More...

class	HybridJunctionTree

class	HybridNonlinearFactor
	Implementation of a discrete-conditioned hybrid factor. More...

class	HybridNonlinearFactorGraph

class	HybridNonlinearISAM

class	HybridSmoother

class	HybridValues

class	IMUFactor

class	ImuFactor

class	ImuFactor2

class	ImuMeasurement
	Contains data from the IMU mesaurements. More...

class	InconsistentEliminationRequested

class	IncrementalFixedLagSmoother

class	IndeterminantLinearSystemException

struct	index_sequence

class	IndexPair
	Small utility class for representing a wrappable pairs of ints. More...

class	InequalityFactorGraph

class	InertialNavFactor_GlobalVelocity

class	InfeasibleInitialValues

class	InfeasibleOrUnboundedProblem

struct	InitializePose3

class	InvalidArgumentThreadsafe
	Thread-safe invalid argument exception. More...

class	InvalidDenseElimination

class	InvalidMatrixBlock

class	InvalidNoiseModel

class	InvDepthCamera3

class	InvDepthFactor3

class	InvDepthFactorVariant1

class	InvDepthFactorVariant2

class	InvDepthFactorVariant3a

class	InvDepthFactorVariant3b

class	ISAM

class	ISAM2

class	ISAM2BayesTree

class	ISAM2Clique

struct	ISAM2DoglegParams

struct	ISAM2GaussNewtonParams

class	ISAM2JunctionTree

struct	ISAM2Params

struct	ISAM2Result

struct	ISAM2UpdateParams

class	IsGroup

class	IsLieGroup

class	IsTestable

class	IsVectorSpace
	Vector Space concept. More...

class	IterativeOptimizationParameters

class	IterativeSolver

class	JacobianFactor

class	JacobianFactorQ

class	JacobianFactorQR

class	JacobianFactorSVD

class	JointMarginal

class	JunctionTree

class	KalmanFilter

class	KarcherMeanFactor

class	key_formatter

class	KeyInfo

struct	KeyInfoEntry

class	LabeledSymbol

class	LevenbergMarquardtOptimizer

class	LevenbergMarquardtParams

struct	lie_group_tag
	tag to assert a type is a Lie group More...

struct	LieGroup

class	Line3

class	LinearContainerFactor

class	LinearCost

class	LinearEquality

class	LinearInequality

class	LinearizedGaussianFactor

class	LinearizedHessianFactor

class	LinearizedJacobianFactor

class	LocalOrientedPlane3Factor

struct	LP

class	LPInitSolver

struct	LPPolicy
	Policy for ActivetSetSolver to solve Linear Programming. More...

class	MagFactor

class	MagFactor1

class	MagFactor2

class	MagFactor3

class	MagPoseFactor

struct	make_index_sequence

struct	make_index_sequence< 0 >

struct	make_index_sequence< 1 >

struct	MakeJacobian
	: meta-function to generate Jacobian More...

struct	MakeOptionalJacobian
	: meta-function to generate JacobianTA optional reference Used mainly by Expressions More...

struct	manifold_tag
	tag to assert a type is a manifold More...

class	ManifoldEvaluationFactor

class	ManifoldPreintegration

class	MarginalizeNonleafException

class	Marginals

struct	MatrixProdFunctor

class	Measurement
	This is the base class for all measurement types. More...

class	Mechanization_bRn2

class	MetisIndex

class	MFAS

class	MinHeap
	Min-Heap class to help with pruning. The `top` element is always the smallest value. More...

struct	multiplicative_group_tag
	Group operator syntax flavors. More...

struct	MultiplyWithInverse

struct	MultiplyWithInverseFunction

class	MultiProjectionFactor

class	NavState

struct	needs_eigen_aligned_allocator

struct	needs_eigen_aligned_allocator< T, void_t< typename T::_eigen_aligned_allocator_trait > >

class	NoiseModelFactor

class	NoiseModelFactorN

class	NoMatchFoundForFixed

class	NonlinearClusterTree

class	NonlinearConjugateGradientOptimizer

class	NonlinearEquality

class	NonlinearEquality1

class	NonlinearEquality2

class	NonlinearFactor

class	NonlinearFactorGraph

class	NonlinearISAM

class	NonlinearOptimizer

class	NonlinearOptimizerParams

class	OdometryFactorBase

class	OptionalJacobian

class	OptionalJacobian< Eigen::Dynamic, Eigen::Dynamic >

class	Ordering

class	ordering_key_visitor

class	OrientedPlane3
	Represents an infinite plane in 3D, which is composed of a planar normal and its perpendicular distance to the origin. Currently it provides a transform of the plane, and a norm 1 differencing of two planes. Refer to Trevor12iros for more math details. More...

class	OrientedPlane3DirectionPrior

class	OrientedPlane3Factor

class	OutOfRangeThreadsafe
	Thread-safe out of range exception. More...

struct	ParseFactor

struct	ParseMeasurement

struct	ParseMeasurement< BearingRange2D >

struct	ParseMeasurement< Pose2 >

struct	ParseMeasurement< Pose3 >

class	PartialPriorFactor

class	ParticleFactor

class	ParticleFilter

class	PCGSolver

struct	PCGSolverParameters

class	PendulumFactor1

class	PendulumFactor2

class	PendulumFactorPk

class	PendulumFactorPk1

class	PinholeBase

class	PinholeBaseK

class	PinholeCamera

class	PinholeFactor

class	PinholePose

class	PinholeSet

class	Pose2

class	Pose3

class	Pose3AttitudeFactor

class	Pose3Upright

class	PoseBetweenFactor

class	PoseConcept

class	PosePriorFactor

class	PoseRotationPrior

class	PoseRTV

class	PoseToPointFactor

class	PoseTranslationPrior

class	PowerMethod
	Compute maximum Eigenpair with power method. More...

class	Preconditioner

struct	PreconditionerParameters

class	PredecessorMap

class	PreintegratedAhrsMeasurements

class	PreintegratedCombinedMeasurements

class	PreintegratedImuMeasurements

class	PreintegratedRotation

struct	PreintegratedRotationParams

class	PreintegrationBase

struct	PreintegrationCombinedParams

struct	PreintegrationParams

class	PriorFactor

class	ProductLieGroup

class	ProjectionFactorPPP

class	ProjectionFactorPPPC

class	ProjectionFactorRollingShutter

struct	QP

class	QPInitSolver

struct	QPPolicy
	Policy for ActivetSetSolver to solve Linear Programming. More...

class	QPSParser

class	QPSParserException

class	QPSVisitor

struct	Range

struct	Range< CalibratedCamera, T >

struct	Range< PinholeCamera< Calibration >, T >

struct	Range< Point2, Point2 >

struct	Range< Point3, Point3 >

struct	Range< Pose2, T >

struct	Range< Pose3, T >

struct	Range< PoseRTV, PoseRTV >

struct	Range< Vector4, Vector4 >

class	RangeFactor

class	RangeFactorWithTransform

class	Reconstruction

struct	RedirectCout

class	ReferenceFrameFactor

class	RegularHessianFactor

class	RegularImplicitSchurFactor

class	RegularJacobianFactor

class	RelativeElevationFactor

struct	Reshape
	Reshape functor. More...

struct	Reshape< M, M, InOptions, M, M, InOptions >
	Reshape specialization that does nothing as shape stays the same (needed to not be ambiguous for square input equals square output) More...

struct	Reshape< M, N, InOptions, M, N, InOptions >
	Reshape specialization that does nothing as shape stays the same. More...

struct	Reshape< N, M, InOptions, M, N, InOptions >
	Reshape specialization that does transpose. More...

struct	Result
	Result from elimination. More...

class	Rot2

class	Rot3
	Rot3 is a 3D rotation represented as a rotation matrix if the preprocessor symbol GTSAM_USE_QUATERNIONS is not defined, or as a quaternion if it is defined. More...

class	Rot3AttitudeFactor

class	RotateDirectionsFactor

class	RotateFactor

class	RuntimeErrorThreadsafe
	Thread-safe runtime error exception. More...

class	Sampler

class	ScalarMultiplyExpression

class	Scatter

class	Scenario
	Simple trajectory simulator. More...

class	ScenarioRunner

class	Scheduler

class	SDGraph

struct	SfmData
	SfmData stores a bunch of SfmTracks. More...

struct	SfmTrack

struct	SfmTrack2d
	Track containing 2D measurements associated with a single 3D point. Note: Equivalent to gtsam.SfmTrack, but without the 3d measurement. This class holds data temporarily before 3D point is initialized. More...

class	SGraph

class	ShonanAveraging

class	ShonanAveraging2

class	ShonanAveraging3

struct	ShonanAveragingParameters
	Parameters governing optimization etc. More...

class	ShonanFactor

class	ShonanGaugeFactor

class	Signature

struct	SignatureParser
	A simple parser that replaces the boost spirit parser. More...

class	Similarity2

class	Similarity3

class	SimpleFundamentalMatrix
	Class for representing a simple fundamental matrix. More...

class	SimPolygon2D

class	SimWall2D

class	SingleValue

struct	SlotEntry
	One SlotEntry stores the slot index for a variable, as well its dim. More...

class	SmartFactorBase
	Base class for smart factors. This base class has no internal point, but it has a measurement, noise model and an optional sensor pose. This class mainly computes the derivatives and returns them as a variety of factors. The methods take a CameraSet<CAMERA> argument and the value of a point, which is kept in the derived class. More...

class	SmartProjectionFactor

struct	SmartProjectionParams

class	SmartProjectionPoseFactor

class	SmartProjectionPoseFactorRollingShutter

class	SmartProjectionRigFactor

class	SmartRangeFactor

class	SmartStereoProjectionFactor

class	SmartStereoProjectionFactorPP

class	SmartStereoProjectionPoseFactor

class	SO

class	SphericalCamera

class	StereoCamera

class	StereoCheiralityException

class	StereoFactor

class	StereoPoint2

struct	StreamedKey
	To use the key_formatter on Keys, they must be wrapped in a StreamedKey. More...

class	Subgraph

class	SubgraphBuilder

struct	SubgraphBuilderParameters

class	SubgraphPreconditioner

struct	SubgraphPreconditionerParameters

class	SubgraphSolver

struct	SubgraphSolverParameters

struct	Switching
	ϕ(X(0)) .. ϕ(X(k),X(k+1)) .. ϕ(X(k);z_k) .. ϕ(M(0)) .. ϕ(M(K-3),M(K-2)) More...

class	Symbol

class	SymbolGenerator

class	SymbolicBayesNet

class	SymbolicBayesTree

class	SymbolicBayesTreeClique
	A clique in a SymbolicBayesTree. More...

class	SymbolicConditional

class	SymbolicEliminationTree

class	SymbolicFactor

class	SymbolicFactorGraph

class	SymbolicISAM

class	SymbolicJunctionTree

class	Symmetric
	Symmetric group. More...

class	SymmetricBlockMatrix

class	System

class	TableFactor

class	TangentPreintegration

class	TbbOpenMPMixedScope

struct	Testable

class	TestOptionalStruct

class	ThreadsafeException
	Base exception type that uses tbb_allocator if GTSAM is compiled with TBB. More...

class	TimeOfArrival
	Time of arrival to given sensor. More...

class	TOAFactor
	A "Time of Arrival" factor - so little code seems hardly worth it :-) More...

struct	traits

struct	traits< ADT >

struct	traits< AlgebraicDecisionTree< T > >

struct	traits< BearingFactor< A1, A2, T > >
	traits More...

struct	traits< BearingRange< A1, A2 > >

struct	traits< BearingRangeFactor< A1, A2, B, R > >
	traits More...

struct	traits< BearingS2 >
	traits More...

struct	traits< BetweenConstraint< VALUE > >
	traits More...

struct	traits< BetweenFactor< VALUE > >
	traits More...

struct	traits< BetweenFactorEM< VALUE > >
	traits More...

struct	traits< BinaryJacobianFactor< M, N1, N2 > >

struct	traits< Cal3_S2 >

struct	traits< Cal3_S2Stereo >

struct	traits< Cal3Bundler >

struct	traits< Cal3Bundler0 >

struct	traits< Cal3DS2 >

struct	traits< Cal3f >

struct	traits< Cal3Fisheye >

struct	traits< Cal3Unified >

struct	traits< CalibratedCamera >

struct	traits< CallConfig >

struct	traits< CameraSet< CAMERA > >

struct	traits< Class >

struct	traits< CombinedImuFactor >

struct	traits< ConcurrentBatchFilter >
	traits More...

struct	traits< ConcurrentBatchSmoother >
	traits More...

struct	traits< ConcurrentIncrementalFilter >
	traits More...

struct	traits< ConcurrentIncrementalSmoother >
	traits More...

struct	traits< const Cal3_S2 >

struct	traits< const Cal3_S2Stereo >

struct	traits< const Cal3Bundler >

struct	traits< const Cal3DS2 >

struct	traits< const Cal3f >

struct	traits< const Cal3Fisheye >

struct	traits< const Cal3Unified >

struct	traits< const CalibratedCamera >

struct	traits< const CameraSet< CAMERA > >

struct	traits< const EssentialMatrix >

struct	traits< const Line3 >

struct	traits< const OrientedPlane3 >

struct	traits< const PinholeCamera< Calibration > >

struct	traits< const PinholePose< CALIBRATION > >

struct	traits< const PinholeSet< CAMERA > >

struct	traits< const Pose2 >

struct	traits< const Pose3 >

struct	traits< const Rot2 >

struct	traits< const Rot3 >

struct	traits< const Similarity2 >

struct	traits< const Similarity3 >

struct	traits< const SO3 >

struct	traits< const SO4 >

struct	traits< const SO< N > >

struct	traits< const SphericalCamera >

struct	traits< const StereoCamera >

struct	traits< const StereoPoint2 >

struct	traits< const Unit3 >

struct	traits< CrazyDecisionTree >

struct	traits< Cyclic< N > >
	Define cyclic group to be a model of the Additive Group concept. More...

struct	traits< DecisionTree< L, Y > >

struct	traits< DecisionTreeFactor >

struct	traits< Dih6 >

struct	traits< DirectProduct< G, H > >

struct	traits< DirectSum< G, H > >

struct	traits< DiscreteBayesNet >

struct	traits< DiscreteBayesTree >

struct	traits< DiscreteBayesTreeClique >
	traits More...

struct	traits< DiscreteConditional >

struct	traits< DiscreteDistribution >

struct	traits< DiscreteFactor >

struct	traits< DiscreteFactorGraph >
	traits More...

struct	traits< DiscreteKeys >

struct	traits< DiscreteLookupDAG >

struct	traits< DiscreteValues >

struct	traits< double >
	double More...

struct	traits< DT >

struct	traits< EdgeKey >
	traits More...

struct	traits< Eigen::Matrix< double, -1, -1, Options, MaxRows, MaxCols > >

struct	traits< Eigen::Matrix< double, -1, 1, Options, MaxRows, MaxCols > >

struct	traits< Eigen::Matrix< double, 1, -1, Options, MaxRows, MaxCols > >

struct	traits< Eigen::Matrix< double, M, N, Options, MaxRows, MaxCols > >

struct	traits< EqualityFactorGraph >
	traits More...

struct	traits< Errors >
	traits More...

struct	traits< EssentialMatrix >

struct	traits< Event >

struct	traits< ExpressionFactor< T > >
	traits More...

struct	traits< ExpressionFactorN< T, Args... > >
	traits More...

struct	traits< float >
	float More...

struct	traits< FunctorizedFactor2< R, T1, T2 > >
	traits More...

struct	traits< FunctorizedFactor< R, T > >
	traits More...

struct	traits< FundamentalMatrix >

struct	traits< GaussianBayesNet >
	traits More...

struct	traits< GaussianBayesTree >
	traits More...

struct	traits< GaussianConditional >
	traits More...

struct	traits< GaussianFactor >
	traits More...

struct	traits< GaussianFactorGraph >
	traits More...

struct	traits< GaussianISAM >
	traits More...

struct	traits< GaussMarkov1stOrderFactor< VALUE > >
	traits More...

struct	traits< GeneralSFMFactor2< CALIBRATION > >

struct	traits< GeneralSFMFactor< CAMERA, LANDMARK > >

struct	traits< GenericProjectionFactor< POSE, LANDMARK, CALIBRATION > >
	traits More...

struct	traits< GenericStereoFactor< T1, T2 > >
	traits More...

struct	traits< GenericValue< ValueType > >

struct	traits< HessianFactor >
	traits More...

struct	traits< HybridBayesNet >
	traits More...

struct	traits< HybridBayesTree >

struct	traits< HybridBayesTreeClique >
	traits More...

struct	traits< HybridConditional >

struct	traits< HybridFactor >

struct	traits< HybridGaussianConditional >

struct	traits< HybridGaussianFactor >

struct	traits< HybridGaussianFactorGraph >

struct	traits< HybridGaussianISAM >
	traits More...

struct	traits< HybridGaussianProductFactor >

struct	traits< HybridNonlinearFactor >

struct	traits< HybridNonlinearFactorGraph >

struct	traits< HybridValues >

struct	traits< imuBias::ConstantBias >

struct	traits< ImuFactor >

struct	traits< ImuFactor2 >

struct	traits< InequalityFactorGraph >
	traits More...

struct	traits< InertialNavFactor_GlobalVelocity< POSE, VELOCITY, IMUBIAS > >
	traits More...

struct	traits< ISAM2 >
	traits More...

struct	traits< JacobianFactor >
	traits More...

struct	traits< JacobianFactorQ< D, ZDim > >

struct	traits< K4 >
	Define K4 to be a model of the Additive Group concept, and provide Testable. More...

struct	traits< Key >

struct	traits< LabeledSymbol >
	traits More...

struct	traits< Line3 >

struct	traits< LinearContainerFactor >

struct	traits< LinearCost >
	traits More...

struct	traits< LinearEquality >
	traits More...

struct	traits< LinearInequality >
	traits More...

struct	traits< LinearizedHessianFactor >
	traits More...

struct	traits< LinearizedJacobianFactor >
	traits More...

struct	traits< LP >
	traits More...

struct	traits< MyType >

struct	traits< NavState >

struct	traits< noiseModel::Constrained >

struct	traits< noiseModel::Diagonal >

struct	traits< noiseModel::Gaussian >
	traits More...

struct	traits< noiseModel::Isotropic >

struct	traits< noiseModel::Unit >

struct	traits< NonlinearEquality1< VALUE > >

struct	traits< NonlinearEquality2< VALUE > >

struct	traits< NonlinearEquality< VALUE > >

struct	traits< NonlinearFactor >
	traits More...

struct	traits< NonlinearFactorGraph >
	traits More...

struct	traits< Ordering >
	traits More...

struct	traits< OrientedPlane3 >

struct	traits< PinholeCamera< Calibration > >

struct	traits< PinholeFactor >
	traits More...

struct	traits< PinholePose< CALIBRATION > >

struct	traits< PinholeSet< CAMERA > >

struct	traits< Pose2 >

struct	traits< Pose3 >

struct	traits< Pose3AttitudeFactor >
	traits More...

struct	traits< Pose3Upright >

struct	traits< PoseRTV >

struct	traits< PreintegratedCombinedMeasurements >

struct	traits< PreintegratedImuMeasurements >

struct	traits< PreintegratedRotation >

struct	traits< PreintegrationCombinedParams >

struct	traits< PriorFactor< VALUE > >
	traits More...

struct	traits< Product >

struct	traits< ProductLieGroup< G, H > >

struct	traits< ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > >
	traits More...

struct	traits< ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > >
	traits More...

struct	traits< ProjectionFactorRollingShutter >
	traits More...

struct	traits< QUATERNION_TYPE >

struct	traits< RangeFactor< A1, A2, T > >
	traits More...

struct	traits< RangeFactorWithTransform< A1, A2, T > >
	traits More...

struct	traits< ReferenceFrameFactor< T1, T2 > >
	traits More...

struct	traits< RegularHessianFactor< D > >

struct	traits< RegularImplicitSchurFactor< CAMERA > >

struct	traits< Rot2 >

struct	traits< Rot3 >

struct	traits< Rot3AttitudeFactor >
	traits More...

struct	traits< SfmData >
	traits More...

struct	traits< SfmTrack >

struct	traits< Similarity2 >

struct	traits< Similarity3 >

struct	traits< SimpleFundamentalMatrix >

struct	traits< simulated2D::GenericMeasurement< POSE, LANDMARK > >

struct	traits< simulated2D::Values >

struct	traits< SimWall2D >
	traits More...

struct	traits< SmartProjectionFactor< CAMERA > >
	traits More...

struct	traits< SmartProjectionPoseFactor< CALIBRATION > >
	traits More...

struct	traits< SmartProjectionPoseFactorRollingShutter< CAMERA > >
	traits More...

struct	traits< SmartProjectionRigFactor< CAMERA > >
	traits More...

struct	traits< SmartStereoProjectionFactor >
	traits More...

struct	traits< SmartStereoProjectionFactorPP >
	traits More...

struct	traits< SmartStereoProjectionPoseFactor >
	traits More...

struct	traits< SO3 >

struct	traits< SO4 >

struct	traits< SO< N > >

struct	traits< SphericalCamera >

struct	traits< StereoCamera >

struct	traits< StereoFactor >
	traits More...

struct	traits< StereoPoint2 >

struct	traits< Symbol >
	traits More...

struct	traits< SymbolicBayesNet >
	traits More...

struct	traits< SymbolicBayesTree >

struct	traits< SymbolicBayesTreeClique >
	traits More...

struct	traits< SymbolicConditional >
	traits More...

struct	traits< SymbolicEliminationTree >
	traits More...

struct	traits< SymbolicFactor >
	traits More...

struct	traits< SymbolicFactorGraph >
	traits More...

struct	traits< Symmetric< N > >
	Define permutation group traits to be a model of the Multiplicative Group concept. More...

struct	traits< TableFactor >

struct	traits< TestOptionalStruct >

struct	traits< TestPartialPriorFactor2 >

struct	traits< TestPartialPriorFactor3 >

struct	traits< TestPoseBetweenFactor >

struct	traits< TestPosePriorFactor >

struct	traits< TestProjectionFactor >

struct	traits< TestValue >

struct	traits< TransformBtwRobotsUnaryFactor< VALUE > >
	traits More...

struct	traits< TransformBtwRobotsUnaryFactorEM< VALUE > >
	traits More...

struct	traits< Unit3 >

struct	traits< Values >
	traits More...

struct	traits< VariableIndex >
	traits More...

struct	traits< VariableSlots >
	traits More...

struct	traits< VectorValues >
	traits More...

class	TransferEdges

class	TransferFactor

class	TransformBtwRobotsUnaryFactor

class	TransformBtwRobotsUnaryFactorEM

class	TransformCovariance

class	TranslationFactor

class	TranslationRecovery

class	TriangulationCheiralityException
	Exception thrown by triangulateDLT when landmark is behind one or more of the cameras. More...

class	TriangulationFactor

struct	TriangulationParameters

class	TriangulationResult

class	TriangulationUnderconstrainedException
	Exception thrown by triangulateDLT when SVD returns rank < 3. More...

struct	TripleF

class	Unit3
	Represents a 3D point on a unit sphere. More...

struct	UpdateImpl

class	Value

class	ValueCloneAllocator

class	Values

struct	ValuesCastHelper

struct	ValuesCastHelper< const Value, CastedKeyValuePairType, KeyValuePairType >

struct	ValuesCastHelper< Value, CastedKeyValuePairType, KeyValuePairType >

class	ValuesIncorrectType

class	ValuesKeyAlreadyExists

class	ValuesKeyDoesNotExist

struct	ValueWithDefault

class	VariableIndex

class	VariableSlots

struct	vector_space_tag
	tag to assert a type is a vector space More...

class	VectorComponentFactor

class	VectorDerivativeFactor

class	VectorEvaluationFactor

class	VectorValues

class	VelocityConstraint

class	VelocityConstraint3

struct	VelocityPrior

class	VerticalBlockMatrix

struct	Visit

struct	VisitLeaf

struct	VisitWith

class	WeightedSampler

class	WhiteNoiseFactor
	Binary factor to estimate parameters of zero-mean Gaussian white noise. More...

Typedefs
typedef qi::grammar< boost::spirit::basic_istream_iterator< char > >	base_grammar

using	BearingRange2D = BearingRange< Pose2, Point2 >

using	BetweenFactorPose2s = list

using	BetweenFactorPose3s = list

using	BinaryMeasurementsPoint3 = list

using	BinaryMeasurementsRot3 = list

using	BinaryMeasurementsUnit3 = list

typedef Expression< Cal3_S2 >	Cal3_S2_

typedef Expression< Cal3Bundler >	Cal3Bundler_

typedef PinholeCamera< Cal3Bundler0 >	Camera

using	CameraSetCal3_S2 = CameraSet< PinholeCamera< Cal3_S2 > >

using	CameraSetCal3Bundler = CameraSet< PinholeCamera< Cal3Bundler > >

using	CameraSetCal3DS2 = CameraSet< PinholeCamera< Cal3DS2 > >

using	CameraSetCal3Fisheye = CameraSet< PinholeCamera< Cal3Fisheye > >

using	CameraSetCal3Unified = CameraSet< PinholeCamera< Cal3Unified > >

using	CameraSetSpherical = CameraSet< SphericalCamera >

typedef ConcurrentBatchFilter::Result	ConcurrentBatchFilterResult
	Typedef for Matlab wrapping. More...

typedef ConcurrentBatchSmoother::Result	ConcurrentBatchSmootherResult
	Typedef for Matlab wrapping. More...

typedef ConcurrentIncrementalFilter::Result	ConcurrentIncrementalFilterResult
	Typedef for Matlab wrapping. More...

typedef ConcurrentIncrementalSmoother::Result	ConcurrentIncrementalSmootherResult
	Typedef for Matlab wrapping. More...

typedef Eigen::Block< const Matrix >	ConstSubMatrix

typedef Eigen::VectorBlock< const Vector >	ConstSubVector

using	CustomErrorFunction = std::function< Vector(const CustomFactor &, const Values &, const JacobianVector *)>

typedef ptrdiff_t	DenseIndex
	The index type for Eigen objects. More...

typedef DirectProduct< S2, S3 >	Dih6

using	Dims = std::vector< Key >

using	DiscreteCluster = DiscreteJunctionTree::Cluster
	typedef for wrapper: More...

using	DiscreteKey = std::pair< Key, size_t >

using	Domains = std::map< Key, Domain >

typedef Expression< double >	Double_

typedef DSF< int >	DSFInt

typedef DSFMap< IndexPair >	DSFMapIndexPair

using	DynamicJacobian = OptionalJacobian< Eigen::Dynamic, Eigen::Dynamic >

template<bool B, class T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
	An shorthand alias for accessing the ::type inside std::enable_if that can be used in a template directly. More...

using	Errors = FastList< Vector >
	Errors is a vector of errors. More...

typedef std::uint64_t	FactorIndex
	Integer nonlinear factor index type. More...

typedef FastSet< FactorIndex >	FactorIndexSet

typedef FastVector< FactorIndex >	FactorIndices
	Define collection types: More...

template<typename T >
using	FastVector = std::vector< T, typename internal::FastDefaultVectorAllocator< T >::type >

typedef FixedLagSmoother::KeyTimestampMap	FixedLagSmootherKeyTimestampMap
	Typedef for matlab wrapping. More...

typedef FixedLagSmootherKeyTimestampMap::value_type	FixedLagSmootherKeyTimestampMapValue

typedef FixedLagSmoother::Result	FixedLagSmootherResult

using	GaussianFactorGraphValuePair = std::pair< GaussianFactorGraph, double >

using	GaussianFactorValuePair = std::pair< GaussianFactor::shared_ptr, double >
	Alias for pair of GaussianFactor::shared_pointer and a double value. More...

using	GraphAndValues = std::pair< NonlinearFactorGraph::shared_ptr, Values::shared_ptr >

template<class... T>
using	index_sequence_for = make_index_sequence< sizeof...(T)>

typedef std::pair< std::pair< size_t, size_t >, Pose2 >	IndexedEdge

typedef std::pair< size_t, Point2 >	IndexedLandmark

typedef std::pair< size_t, Pose2 >	IndexedPose
	Return type for auxiliary functions. More...

typedef std::set< IndexPair >	IndexPairSet

typedef std::map< IndexPair, IndexPairSet >	IndexPairSetMap = dict

typedef std::vector< IndexPair >	IndexPairVector = list

typedef FastMap< char, Vector >	ISAM2ThresholdMap

typedef ISAM2ThresholdMap::value_type	ISAM2ThresholdMapValue

using	JacobianVector = std::vector< Matrix >

typedef std::uint64_t	Key
	Integer nonlinear key type. More...

using	KeyDimMap = std::map< Key, uint32_t >
	Mapping between variable's key and its corresponding dimensionality. More...

using	KeyFormatter = std::function< std::string(Key)>
	Typedef for a function to format a key, i.e. to convert it to a string. More...

using	KeyGroupMap = FastMap< Key, int >

using	KeyList = FastList< Key >

typedef std::map< std::pair< Key, Key >, double >	KeyPairDoubleMap = dict

typedef std::map< Key, Rot3 >	KeyRotMap

using	KeySet = FastSet< Key >

using	KeyVector = list
	Define collection type once and for all - also used in wrappers. More...

typedef std::map< Key, std::vector< size_t > >	KeyVectorMap

typedef Expression< Line3 >	Line3_

using	LPSolver = ActiveSetSolver< LP, LPPolicy, LPInitSolver >

typedef Eigen::MatrixXd	Matrix

typedef Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >	MatrixRowMajor

using	MotionModel = BetweenFactor< double >

typedef Expression< NavState >	NavState_

using	NonlinearFactorValuePair = std::pair< NoiseModelFactor::shared_ptr, double >
	Alias for a NoiseModelFactor shared pointer and double scalar pair. More...

using	OptionalMatrixType = Matrix *

using	OptionalMatrixVecType = std::vector< Matrix > *

typedef Expression< OrientedPlane3 >	OrientedPlane3_

using	OrphanWrapper = BayesTreeOrphanWrapper< HybridBayesTree::Clique >

using	Pairs = std::vector< std::pair< Key, Matrix > >

template<typename T >
using	Parser = std::function< std::optional< T >(std::istream &is, const std::string &tag)>

using	PinholeCameraCal3_S2 = gtsam::PinholeCamera< gtsam::Cal3_S2 >

using	PinholeCameraCal3Bundler = gtsam::PinholeCamera< gtsam::Cal3Bundler >

using	PinholeCameraCal3DS2 = gtsam::PinholeCamera< gtsam::Cal3DS2 >

using	PinholeCameraCal3Fisheye = gtsam::PinholeCamera< gtsam::Cal3Fisheye >

using	PinholeCameraCal3Unified = gtsam::PinholeCamera< gtsam::Cal3Unified >

typedef Vector2	Point2

typedef Expression< Point2 >	Point2_

using	Point2Pair = std::pair< Point2, Point2 >

using	Point2Pairs = list

typedef std::vector< Point2, Eigen::aligned_allocator< Point2 > >	Point2Vector = list

typedef Vector3	Point3

typedef Expression< Point3 >	Point3_

using	Point3Pair = std::pair< Point3, Point3 >

using	Point3Pairs = list

typedef std::vector< Point3, Eigen::aligned_allocator< Point3 > >	Point3Vector

typedef Expression< Pose2 >	Pose2_

using	Pose2Pair = std::pair< Pose2, Pose2 >

using	Pose2Pairs = list

typedef Expression< Pose3 >	Pose3_

using	Pose3Pair = std::pair< Pose3, Pose3 >

using	Pose3Pairs = list

typedef std::vector< Pose3 >	Pose3Vector = list

typedef ManifoldPreintegration	PreintegrationType

using	QPSolver = ActiveSetSolver< QP, QPPolicy, QPInitSolver >

typedef Eigen::Quaternion< double, Eigen::DontAlign >	Quaternion

using	ResultTree = DecisionTree< Key, Result >

typedef Expression< Rot2 >	Rot2_

typedef Expression< Rot3 >	Rot3_

using	Rot3Vector = list
	std::vector of Rot3s, used in Matlab wrapper More...

using	Row = std::vector< double >

typedef Eigen::RowVectorXd	RowVector

using	Sample = std::pair< double, double >
	A sample is a key-value pair from a sequence. More...

using	Sequence = std::map< double, double >
	Our sequence representation is a map of {x: y} values where y = f(x) More...

typedef PinholeCamera< Cal3Bundler >	SfmCamera
	Define the structure for the camera poses. More...

typedef std::pair< size_t, Point2 >	SfmMeasurement
	A measurement with its camera index. More...

using	SfmTrack2dVector = list

typedef noiseModel::Constrained::shared_ptr	SharedConstrained

typedef noiseModel::Diagonal::shared_ptr	SharedDiagonal

using	SharedFactor = std::shared_ptr< Factor >

typedef noiseModel::Gaussian::shared_ptr	SharedGaussian

typedef noiseModel::Isotropic::shared_ptr	SharedIsotropic

typedef noiseModel::Base::shared_ptr	SharedNoiseModel

using	ShonanAveragingParameters2 = ShonanAveragingParameters< 2 >

using	ShonanAveragingParameters3 = ShonanAveragingParameters< 3 >

using	ShonanFactor2 = ShonanFactor< 2 >

using	ShonanFactor3 = ShonanFactor< 3 >

typedef std::pair< size_t, size_t >	SiftIndex
	Sift index for SfmTrack. More...

typedef std::vector< SimPolygon2D >	SimPolygon2DVector

typedef std::vector< SimWall2D >	SimWall2DVector

typedef SmartProjectionParams	SmartStereoProjectionParams

using	SO3 = SO< 3 >

using	SO4 = SO< 4 >

using	SOn = SO< Eigen::Dynamic >

using	Sparse = Eigen::SparseMatrix< double >

typedef Eigen::SparseMatrix< double, Eigen::ColMajor, int >	SparseEigen

using	SparseTriplets = std::vector< std::tuple< int, int, double > >

typedef internal::DoglegState	State

typedef std::vector< StereoPoint2 >	StereoPoint2Vector

typedef Eigen::Block< Matrix >	SubMatrix

typedef Eigen::VectorBlock< Vector >	SubVector

typedef NonlinearOptimizerParams	SuccessiveLinearizationParams

using	SymbolicCluster = SymbolicJunctionTree::Cluster
	typedef for wrapper: More...

using	Table = std::vector< Row >

typedef Expression< Unit3 >	Unit3_

typedef Eigen::VectorXd	Vector

typedef Eigen::Matrix< double, 1, 1 >	Vector1

typedef Expression< Vector1 >	Vector1_

typedef Eigen::Vector2d	Vector2

typedef Expression< Vector2 >	Vector2_

typedef Eigen::Vector3d	Vector3

typedef Expression< Vector3 >	Vector3_

typedef Expression< Vector4 >	Vector4_

typedef Expression< Vector5 >	Vector5_

typedef Expression< Vector6 >	Vector6_

typedef Expression< Vector7 >	Vector7_

typedef Expression< Vector8 >	Vector8_

typedef Expression< Vector9 >	Vector9_

typedef Vector3	Velocity3
	Velocity is currently typedef'd to Vector3. More...

typedef Expression< Velocity3 >	Velocity3_

template<typename ... >
using	void_t = void
	Convenience void_t as we assume C++11, it will not conflict the std one in C++17 as this is in `gtsam::` More...

using	Weights = Eigen::Matrix< double, 1, -1 >

using	Y = GaussianFactorGraphValuePair

Enumerations
enum	DegeneracyMode { IGNORE_DEGENERACY, ZERO_ON_DEGENERACY, HANDLE_INFINITY }
	How to manage degeneracy. More...

enum	DirectionMethod { DirectionMethod::FletcherReeves, DirectionMethod::PolakRibiere, DirectionMethod::HestenesStiefel, DirectionMethod::DaiYuan }

enum	GncLossType { GM, TLS }
	Choice of robust loss function for GNC. More...

enum	KernelFunctionType { KernelFunctionTypeNONE, KernelFunctionTypeHUBER, KernelFunctionTypeTUKEY }
	Robust kernel type to wrap around quadratic noise model. More...

enum	LinearizationMode { HESSIAN, IMPLICIT_SCHUR, JACOBIAN_Q, JACOBIAN_SVD }
	Linearization mode: what factor to linearize to. More...

enum	NoiseFormat { NoiseFormatG2O, NoiseFormatTORO, NoiseFormatGRAPH, NoiseFormatCOV, NoiseFormatAUTO }
	Indicates how noise parameters are stored in file. More...

Functions
string	_defaultKeyFormatter (Key key)

def	_init ()

string	_multirobotKeyFormatter (Key key)

template<typename T >
static bool	_truePredicate (const T &)

static Y	add (const Y &y1, const Y &y2)

std::unique_ptr< internal::ExecutionTraceStorage[]>	allocAligned (size_t size)

template<typename L , typename Y >
DecisionTree< L, Y >	apply (const DecisionTree< L, Y > &f, const DecisionTree< L, Y > &g, const typename DecisionTree< L, Y >::Binary &op)
	Apply binary operator `op` to DecisionTree `f`. More...

template<typename L , typename Y >
DecisionTree< L, Y >	apply (const DecisionTree< L, Y > &f, const typename DecisionTree< L, Y >::Unary &op)
	Apply unary operator `op` to DecisionTree `f`. More...

template<typename L , typename Y >
DecisionTree< L, Y >	apply (const DecisionTree< L, Y > &f, const typename DecisionTree< L, Y >::UnaryAssignment &op)
	Apply unary operator `op` with Assignment to DecisionTree `f`. More...

template<class V2 >
bool	assert_container_equal (const std::map< size_t, V2 > &expected, const std::map< size_t, V2 > &actual, double tol=1e-9)

template<class V1 , class V2 >
bool	assert_container_equal (const std::map< V1, V2 > &expected, const std::map< V1, V2 > &actual, double tol=1e-9)

template<class V1 , class V2 >
bool	assert_container_equal (const std::vector< std::pair< V1, V2 > > &expected, const std::vector< std::pair< V1, V2 > > &actual, double tol=1e-9)

template<class V >
bool	assert_container_equal (const V &expected, const V &actual, double tol=1e-9)

template<class V2 >
bool	assert_container_equality (const std::map< size_t, V2 > &expected, const std::map< size_t, V2 > &actual)

template<class V >
bool	assert_container_equality (const V &expected, const V &actual)

bool	assert_equal (const ConstSubVector &expected, const ConstSubVector &actual, double tol)

bool	assert_equal (const Key &expected, const Key &actual, double tol=0.0)

bool	assert_equal (const Matrix &expected, const Matrix &actual, double tol)

bool	assert_equal (const std::list< Matrix > &As, const std::list< Matrix > &Bs, double tol)

template<class V >
bool	assert_equal (const std::optional< V > &expected, const std::optional< V > &actual, double tol=1e-9)

bool	assert_equal (const std::string &expected, const std::string &actual)

bool	assert_equal (const SubVector &expected, const SubVector &actual, double tol)

template<class V >
bool	assert_equal (const V &expected, const std::optional< std::reference_wrapper< const V >> &actual, double tol=1e-9)

template<class V >
bool	assert_equal (const V &expected, const std::optional< V > &actual, double tol=1e-9)

template<class V >
bool	assert_equal (const V &expected, const V &actual, double tol=1e-9)

bool	assert_equal (const Vector &expected, const Vector &actual, double tol)

bool	assert_inequal (const Matrix &A, const Matrix &B, double tol)

template<class V >
bool	assert_inequal (const V &expected, const V &actual, double tol=1e-9)

bool	assert_inequal (const Vector &expected, const Vector &actual, double tol)

template<class V >
bool	assert_print_equal (const std::string &expected, const V &actual, const std::string &s="")

template<class V >
bool	assert_stdout_equal (const std::string &expected, const V &actual)

Rot3_	attitude (const NavState_ &X)

void	axpy (double alpha, const Errors &x, Errors &y)
	BLAS level 2 style AXPY, `y := alpha*x + y` More...

Vector	backSubstituteLower (const Matrix &L, const Vector &b, bool unit)

Vector	backSubstituteUpper (const Matrix &U, const Vector &b, bool unit)

Vector	backSubstituteUpper (const Vector &b, const Matrix &U, bool unit)

template<class T >
T	BCH (const T &X, const T &Y)
	AGC: bracket() only appears in Rot3 tests, should this be used elsewhere? More...

template<typename T >
Expression< T >	between (const Expression< T > &t1, const Expression< T > &t2)

template<class Class >
Class	between_default (const Class &l1, const Class &l2)

double	bound (double a, double min, double max)

GaussianFactorGraph	buildFactorSubgraph (const GaussianFactorGraph &gfg, const Subgraph &subgraph, const bool clone)

VectorValues	buildVectorValues (const Vector &v, const KeyInfo &keyInfo)
	Create VectorValues from a Vector and a KeyInfo class. More...

VectorValues	buildVectorValues (const Vector &v, const Ordering &ordering, const map< Key, size_t > &dimensions)
	Create VectorValues from a Vector. More...

static Point3	CalculateBestAxis (const Point3 &n)

template<typename Cal , size_t Dim>
void	calibrateJacobians (const Cal &calibration, const Point2 &pn, OptionalJacobian< 2, Dim > Dcal={}, OptionalJacobian< 2, 2 > Dp={})

template<class CAMERA >
Point3Vector	calibrateMeasurements (const CameraSet< CAMERA > &cameras, const typename CAMERA::MeasurementVector &measurements)

template<class CAMERA = SphericalCamera>
Point3Vector	calibrateMeasurements (const CameraSet< SphericalCamera > &cameras, const SphericalCamera::MeasurementVector &measurements)

template<class CALIBRATION >
Point3Vector	calibrateMeasurementsShared (const CALIBRATION &cal, const Point2Vector &measurements)

std::vector< DiscreteValues >	cartesianProduct (const DiscreteKeys &keys)
	Free version of CartesianProduct. More...

static void	check (const SharedNoiseModel &noiseModel, size_t m)

template<class CLIQUE >
bool	check_sharedCliques (const std::pair< Key, typename BayesTree< CLIQUE >::sharedClique > &v1, const std::pair< Key, typename BayesTree< CLIQUE >::sharedClique > &v2)

GaussianConditional::shared_ptr	checkConditional (const GaussianFactor::shared_ptr &factor)

GTSAM_EXPORT bool	checkConvergence (const NonlinearOptimizerParams &params, double currentError, double newError)

bool	checkConvergence (double relativeErrorTreshold, double absoluteErrorTreshold, double errorThreshold, double currentError, double newError, NonlinearOptimizerParams::Verbosity verbosity)

static double	Chi2inv (const double alpha, const size_t dofs)

Matrix	cholesky_inverse (const Matrix &A)

pair< size_t, bool >	choleskyCareful (Matrix &ATA, int order)

bool	choleskyPartial (Matrix &ABC, size_t nFrontal, size_t topleft)

static int	choleskyStep (Matrix &ATA, size_t k, size_t order)

std::optional< Point2 >	circleCircleIntersection (double R_d, double r_d, double tol)

list< Point2 >	circleCircleIntersection (Point2 c1, double r1, Point2 c2, double r2, double tol=1e-9)
	Intersect 2 circles. More...

list< Point2 >	circleCircleIntersection (Point2 c1, Point2 c2, std::optional< Point2 > fh)

Matrix	collect (const std::vector< const Matrix * > &matrices, size_t m, size_t n)

Matrix	collect (size_t nrMatrices,...)

DiscreteKeys	CollectDiscreteKeys (const DiscreteKeys &key1, const DiscreteKeys &key2)

template<class LinearGraph >
KeyDimMap	collectKeyDim (const LinearGraph &linearGraph)

KeyVector	CollectKeys (const KeyVector &continuousKeys, const DiscreteKeys &discreteKeys)

KeyVector	CollectKeys (const KeyVector &keys1, const KeyVector &keys2)

template<class MATRIX >
const MATRIX::ConstColXpr	column (const MATRIX &A, size_t j)

Vector	columnNormSquare (const Matrix &A)

template<typename T >
Expression< T >	compose (const Expression< T > &t1, const Expression< T > &t2)

template<class G , class Factor , class POSE , class KEY >
std::shared_ptr< Values >	composePoses (const G &graph, const PredecessorMap< KEY > &tree, const POSE &rootPose)

std::vector< double >	ComputeLeafOrdering (const DiscreteKeys &dkeys, const DecisionTreeFactor &dt)
	Compute the correct ordering of the leaves in the decision tree. More...

Vector	concatVectors (const std::list< Vector > &vs)

Vector	concatVectors (size_t nrVectors,...)

VectorValues	conjugateGradientDescent (const GaussianFactorGraph &fg, const VectorValues &x, const ConjugateGradientParameters &parameters)

Vector	conjugateGradientDescent (const Matrix &A, const Vector &b, const Vector &x, const ConjugateGradientParameters &parameters)

Vector	conjugateGradientDescent (const System &Ab, const Vector &x, const ConjugateGradientParameters &parameters)

template<class S , class V , class E >
V	conjugateGradients (const S &Ab, V x, const ConjugateGradientParameters &parameters, bool steepest)

static void	ConnectVariableFactor (Key key, const KeyFormatter &keyFormatter, size_t i, ostream *os)

static void	ConnectVariables (Key key1, Key key2, const KeyFormatter &keyFormatter, ostream *os)

static std::pair< HybridConditional::shared_ptr, std::shared_ptr< Factor > >	continuousElimination (const HybridGaussianFactorGraph &factors, const Ordering &frontalKeys)

static BinaryMeasurement< Rot3 >	convert (const BetweenFactor< Pose3 >::shared_ptr &f)

static BinaryMeasurement< Rot2 >	convert (const BinaryMeasurement< Pose2 > &p)

static BinaryMeasurement< Rot3 >	convert (const BinaryMeasurement< Pose3 > &p)

SharedNoiseModel	ConvertNoiseModel (const SharedNoiseModel &model, size_t d, bool defaultToUnit)

static BinaryMeasurement< Rot2 >	convertPose2ToBinaryMeasurementRot2 (const BetweenFactor< Pose2 >::shared_ptr &f)

static GaussianFactorGraph	convertToJacobianFactors (const GaussianFactorGraph &gfg)

static std::shared_ptr< Factor >	createDiscreteFactor (const ResultTree &eliminationResults, const DiscreteKeys &discreteSeparator)

Errors	createErrors (const VectorValues &V)
	Break V into pieces according to its start indices. More...

static std::shared_ptr< Factor >	createHybridGaussianFactor (const ResultTree &eliminationResults, const DiscreteKeys &discreteSeparator)

static SharedNoiseModel	createNoiseModel (const Vector6 &v, bool smart, NoiseFormat noiseFormat, KernelFunctionType kernelFunctionType)

template<class CALIBRATION >
Cal3_S2	createPinholeCalibration (const CALIBRATION &cal)

std::vector< Point3 >	createPoints ()
	Create a set of ground-truth landmarks. More...

std::vector< Pose3 >	createPoses (const Pose3 &init=Pose3(Rot3::Ypr(M_PI_2, 0, -M_PI_2), {30, 0, 0}), const Pose3 &delta=Pose3(Rot3::Ypr(0, -M_PI_4, 0), {sin(M_PI_4) 30, 0, 30 (1 - sin(M_PI_4))}), int steps=8)

std::shared_ptr< Preconditioner >	createPreconditioner (const std::shared_ptr< PreconditionerParameters > params)

GTSAM_EXPORT std::string	createRewrittenFileName (const std::string &name)

std::shared_ptr< Sampler >	createSampler (const SharedNoiseModel &model)

template<typename T >
std::vector< Expression< T > >	createUnknowns (size_t n, char c, size_t start)
	Construct an array of leaves. More...

Point3	cross (const Point3 &p, const Point3 &q, OptionalJacobian< 3, 3 > H_p={}, OptionalJacobian< 3, 3 > H_q={})
	cross product More...

Point3_	cross (const Point3_ &a, const Point3_ &b)

static Matrix29	D2dcalibration (double x, double y, double xx, double yy, double xy, double rr, double r4, double pnx, double pny, const Matrix2 &DK)

static Matrix2	D2dintrinsic (double x, double y, double rr, double g, double k1, double k2, double p1, double p2, const Matrix2 &DK)

template<typename Gradient >
double	DaiYuan (const Gradient &currentGradient, const Gradient &prevGradient, const Gradient &direction)
	The Dai-Yuan formula for computing β, the direction of steepest descent. More...

std::string	demangle (const char *name)
	Pretty print Value type name. More...

NonlinearFactorGraph::shared_ptr	deserializeGraph (const std::string &serialized_graph)

NonlinearFactorGraph::shared_ptr	deserializeGraphFromFile (const std::string &fname)

NonlinearFactorGraph::shared_ptr	deserializeGraphFromXMLFile (const std::string &fname, const std::string &name="graph")

NonlinearFactorGraph::shared_ptr	deserializeGraphXML (const std::string &serialized_graph, const std::string &name="graph")

Values::shared_ptr	deserializeValues (const std::string &serialized_values)

Values::shared_ptr	deserializeValuesFromFile (const std::string &fname)

Values::shared_ptr	deserializeValuesFromXMLFile (const std::string &fname, const std::string &name="values")

Values::shared_ptr	deserializeValuesXML (const std::string &serialized_values, const std::string &name="values")

Matrix	diag (const std::vector< Matrix > &Hs)

static noiseModel::Diagonal::shared_ptr	Diagonal (const Matrix &covariance)

static std::pair< HybridConditional::shared_ptr, std::shared_ptr< Factor > >	discreteElimination (const HybridGaussianFactorGraph &factors, const Ordering &frontalKeys)

static DecisionTreeFactor::shared_ptr	DiscreteFactorFromErrors (const DiscreteKeys &discreteKeys, const AlgebraicDecisionTree< Key > &errors)
	Take negative log-values, shift them so that the minimum value is 0, and then exponentiate to create a DecisionTreeFactor (not normalized yet!). More...

std::set< DiscreteKey >	DiscreteKeysAsSet (const DiscreteKeys &discreteKeys)
	Return the DiscreteKey vector as a set. More...

Double_	distance (const OrientedPlane3_ &p)

double	distance2 (const Point2 &p1, const Point2 &q, OptionalJacobian< 1, 2 > H1={}, OptionalJacobian< 1, 2 > H2={})
	distance between two points More...

double	distance3 (const Point3 &p1, const Point3 &q, OptionalJacobian< 1, 3 > H1={}, OptionalJacobian< 1, 3 > H2={})
	distance between two points More...

std::tuple< int, double, Vector >	DLT (const Matrix &A, double rank_tol)

double	dot (const Errors &a, const Errors &b)
	Dot product. More...

double	dot (const Point3 &p, const Point3 &q, OptionalJacobian< 1, 3 > H_p={}, OptionalJacobian< 1, 3 > H_q={})
	dot product More...

Double_	dot (const Point3_ &a, const Point3_ &b)

template<class V1 , class V2 >
double	dot (const V1 &a, const V2 &b)

Vector	ediv_ (const Vector &a, const Vector &b)

std::pair< std::shared_ptr< GaussianConditional >, std::shared_ptr< HessianFactor > >	EliminateCholesky (const GaussianFactorGraph &factors, const Ordering &keys)

std::pair< DiscreteConditional::shared_ptr, DecisionTreeFactor::shared_ptr >	EliminateDiscrete (const DiscreteFactorGraph &factors, const Ordering &frontalKeys)
	Main elimination function for DiscreteFactorGraph. More...

std::pair< DiscreteConditional::shared_ptr, DecisionTreeFactor::shared_ptr >	EliminateForMPE (const DiscreteFactorGraph &factors, const Ordering &frontalKeys)
	Alternate elimination function for that creates non-normalized lookup tables. More...

std::pair< HybridConditional::shared_ptr, std::shared_ptr< Factor > >	EliminateHybrid (const HybridGaussianFactorGraph &factors, const Ordering &keys)
	Main elimination function for HybridGaussianFactorGraph. More...

std::pair< std::shared_ptr< GaussianConditional >, std::shared_ptr< GaussianFactor > >	EliminatePreferCholesky (const GaussianFactorGraph &factors, const Ordering &keys)

std::pair< GaussianConditional::shared_ptr, JacobianFactor::shared_ptr >	EliminateQR (const GaussianFactorGraph &factors, const Ordering &keys)

std::pair< std::shared_ptr< SymbolicConditional >, std::shared_ptr< SymbolicFactor > >	EliminateSymbolic (const SymbolicFactorGraph &factors, const Ordering &keys)

Point2	EpipolarTransfer (const Matrix3 &Fca, const Point2 &pa, const Matrix3 &Fcb, const Point2 &pb)
	Transfer projections from cameras a and b to camera c. More...

template<class T >
bool	equal (const T &obj1, const T &obj2)

template<class T >
bool	equal (const T &obj1, const T &obj2, double tol)

bool	equal (const Vector &vec1, const Vector &vec2)

bool	equal (const Vector &vec1, const Vector &vec2, double tol)

template<class MATRIX >
bool	equal_with_abs_tol (const Eigen::DenseBase< MATRIX > &A, const Eigen::DenseBase< MATRIX > &B, double tol=1e-9)

bool	equal_with_abs_tol (const SubVector &vec1, const SubVector &vec2, double tol)

bool	equal_with_abs_tol (const Vector &vec1, const Vector &vec2, double tol)

bool	equality (const Errors &actual, const Errors &expected, double tol)

Matrix	expm (const Matrix &A, size_t K)

template<class T >
T	expm (const Vector &x, int K=7)

template<class Class >
Class	expmap_default (const Class &t, const Vector &d)

std::vector< double >	expNormalize (const std::vector< double > &logProbs)
	Normalize a set of log probabilities. More...

static ShonanAveraging2::Measurements	extractRot2Measurements (const BetweenFactorPose2s &factors)

static ShonanAveraging3::Measurements	extractRot3Measurements (const BetweenFactorPose3s &factors)

GTSAM_EXPORT std::string	findExampleDataFile (const std::string &name)

template<class T >
T	FindKarcherMean (const std::vector< T > &rotations)

template<class T >
T	FindKarcherMean (const std::vector< T, Eigen::aligned_allocator< T >> &rotations)

template<class T >
T	FindKarcherMean (std::initializer_list< T > &&rotations)

template<class T , class ALLOC >
T	FindKarcherMeanImpl (const vector< T, ALLOC > &rotations)

template<class G , class KEY , class FACTOR2 >
PredecessorMap< KEY >	findMinimumSpanningTree (const G &fg)

template<typename Gradient >
double	FletcherReeves (const Gradient &currentGradient, const Gradient &prevGradient)
	Fletcher-Reeves formula for computing β, the direction of steepest descent. More...

std::string	formatMatrixIndented (const std::string &label, const Matrix &matrix, bool makeVectorHorizontal)

bool	fpEqual (double a, double b, double tol, bool check_relative_also)

static std::vector< Matrix3 >	G3 ({SO3::Hat(Vector3::Unit(0)), SO3::Hat(Vector3::Unit(1)), SO3::Hat(Vector3::Unit(2))})

static std::vector< Matrix4, Eigen::aligned_allocator< Matrix4 > >	G4 ({SO4::Hat(Vector6::Unit(0)), SO4::Hat(Vector6::Unit(1)), SO4::Hat(Vector6::Unit(2)), SO4::Hat(Vector6::Unit(3)), SO4::Hat(Vector6::Unit(4)), SO4::Hat(Vector6::Unit(5))})

template<class T >
GenericValue< T >	genericValue (const T &v)

HybridFactor::Category	GetCategory (const KeyVector &continuousKeys, const DiscreteKeys &discreteKeys)

template<class CALIBRATION >
Pose3_	getPose (const Expression< PinholeCamera< CALIBRATION > > &cam)

static Vector	getSubvector (const Vector &src, const KeyInfo &keyInfo, const KeyVector &keys)

static VectorValues	gradientInPlace (const NonlinearFactorGraph &nfg, const Values &values)
	Return the gradient vector of a nonlinear factor graph. More...

bool	greaterThanOrEqual (const Vector &vec1, const Vector &vec2)

Pose3	gtsam2openGL (const Pose3 &PoseGTSAM)
	This function converts a GTSAM camera pose to an openGL camera pose. More...

Pose3	gtsam2openGL (const Rot3 &R, double tx, double ty, double tz)
	This function converts a GTSAM camera pose to an openGL camera pose. More...

template<typename G >
	GTSAM_CONCEPT_REQUIRES (IsGroup< G >, bool) check_group_invariants(const G &a
	Check invariants. More...

template<typename T >
	GTSAM_CONCEPT_REQUIRES (IsTestable< T >, bool) check_manifold_invariants(const T &a
	Check invariants for Manifold type. More...

bool	guardedIsDebug (const std::string &s)

void	guardedSetDebug (const std::string &s, const bool v)

bool	hasConstraints (const GaussianFactorGraph &factors)

template<typename Gradient >
double	HestenesStiefel (const Gradient &currentGradient, const Gradient &prevGradient, const Gradient &direction)

pair< double, Vector >	house (const Vector &x)

void	householder (Matrix &A, size_t k)

void	householder_ (Matrix &A, size_t k, bool copy_vectors)

double	houseInPlace (Vector &v)

string	html (const DiscreteValues &values, const KeyFormatter &keyFormatter=DefaultKeyFormatter, const DiscreteValues::Names &names={})
	Free version of html. More...

const Ordering	HybridOrdering (const HybridGaussianFactorGraph &graph)
	Return a Colamd constrained ordering where the discrete keys are eliminated after the continuous keys. More...

IndexPairVector	IndexPairSetAsArray (IndexPairSet &set)

Values	initialCamerasAndPointsEstimate (const SfmData &db)
	This function creates initial values for cameras and points from db. More...

Values	initialCamerasEstimate (const SfmData &db)
	This function creates initial values for cameras from db. More...

template<class V1 , class V2 >
double	inner_prod (const V1 &a, const V2 &b)

void	inplace_QR (Matrix &A)

template<typename Derived1 , typename Derived2 >
void	insertSub (Eigen::MatrixBase< Derived1 > &fullMatrix, const Eigen::MatrixBase< Derived2 > &subMatrix, size_t i, size_t j)

template<typename T >
T	interpolate (const T &X, const T &Y, double t, typename MakeOptionalJacobian< T, T >::type Hx={}, typename MakeOptionalJacobian< T, T >::type Hy={})

Matrix	inverse_square_root (const Matrix &A)

static bool	is_linear_dependent (const Matrix &A, const Matrix &B, double tol)

bool	isDebugVersion ()

template<typename T , size_t d>
static double	Kappa (const BinaryMeasurement< T > &measurement, const ShonanAveragingParameters< d > &parameters)

static std::mt19937	kRandomNumberGenerator (42)

Matrix	kroneckerProductIdentity (size_t M, const Weights &w)
	Function for computing the kronecker product of the 1*N Weight vector `w` with the MxM identity matrix `I` efficiently. The main reason for this is so we don't need to use Eigen's Unsupported library. More...

bool	linear_dependent (const Matrix &A, const Matrix &B, double tol)

bool	linear_dependent (const Vector &vec1, const Vector &vec2, double tol)

bool	linear_independent (const Matrix &A, const Matrix &B, double tol)

template<typename T , typename A >
Expression< T >	linearExpression (const std::function< T(A)> &f, const Expression< A > &expression, const Eigen::Matrix< double, traits< T >::dimension, traits< A >::dimension > &dTdA)

JacobianFactor	linearizeNumerically (const NoiseModelFactor &factor, const Values &values, double delta=1e-5)

template<class S , class V , class W >
double	lineSearch (const S &system, const V currentValues, const W &gradient)

Matrix	LLt (const Matrix &A)

GraphAndValues	load2D (const std::string &filename, SharedNoiseModel model, size_t maxIndex, bool addNoise, bool smart, NoiseFormat noiseFormat, KernelFunctionType kernelFunctionType)

GraphAndValues	load2D (std::pair< std::string, SharedNoiseModel > dataset, size_t maxIndex, bool addNoise, bool smart, NoiseFormat noiseFormat, KernelFunctionType kernelFunctionType)

GraphAndValues	load2D_robust (const std::string &filename, const noiseModel::Base::shared_ptr &model, size_t maxIndex)

GraphAndValues	load3D (const std::string &filename)
	Load TORO 3D Graph. More...

template<typename T >
gtsam::Expression< typename gtsam::traits< T >::TangentVector >	logmap (const gtsam::Expression< T > &x1, const gtsam::Expression< T > &x2)
	logmap More...

template<class Class >
Vector	logmap_default (const Class &l0, const Class &lp)

static Symbol	make (gtsam::Key key)

static LabeledSymbol	make (gtsam::Key key)

template<typename T , typename ... Args>
gtsam::enable_if_t< needs_eigen_aligned_allocator< T >::value, std::shared_ptr< T > >	make_shared (Args &&... args)

template<typename T , typename ... Args>
gtsam::enable_if_t<!needs_eigen_aligned_allocator< T >::value, std::shared_ptr< T > >	make_shared (Args &&... args)
	Fall back to the boost version if no need for alignment. More...

std::pair< KeyVector, std::vector< int > >	makeBinaryOrdering (std::vector< Key > &input)
	Return the ordering as a binary tree such that all parent nodes are above their children. More...

template<typename T , typename R , typename FUNC >
FunctorizedFactor< R, T >	MakeFunctorizedFactor (Key key, const R &z, const SharedNoiseModel &model, const FUNC func)

template<typename T1 , typename T2 , typename R , typename FUNC >
FunctorizedFactor2< R, T1, T2 >	MakeFunctorizedFactor2 (Key key1, Key key2, const R &z, const SharedNoiseModel &model, const FUNC func)

HybridGaussianFactorGraph::shared_ptr	makeSwitchingChain (size_t K, std::function< Key(int)> x=X, std::function< Key(int)> m=M, const std::string &transitionProbabilityTable="0 1 1 3")
	Create a switching system chain. A switching system is a continuous system which depends on a discrete mode at each time step of the chain. More...

string	markdown (const DiscreteValues &values, const KeyFormatter &keyFormatter=DefaultKeyFormatter, const DiscreteValues::Names &names={})
	Free version of markdown. More...

const Eigen::IOFormat &	matlabFormat ()

template<class PROBLEM >
Key	maxKey (const PROBLEM &problem)

template<class CONTAINER >
Point3	mean (const CONTAINER &points)
	mean More...

Point2Pair	means (const std::vector< Point2Pair > &abPointPairs)
	Calculate the two means of a set of Point2 pairs. More...

Point3Pair	means (const std::vector< Point3Pair > &abPointPairs)
	Calculate the two means of a set of Point3 pairs. More...

std::pair< Pose2, bool >	moveWithBounce (const Pose2 &cur_pose, double step_size, const std::vector< SimWall2D > walls, Sampler &angle_drift, Sampler &reflect_noise, const Rot2 &bias)

Key	mrsymbol (unsigned char c, unsigned char label, size_t j)
	Create a symbol key from a character, label and index, i.e. xA5. More...

unsigned char	mrsymbolChr (Key key)
	Return the character portion of a symbol key. More...

size_t	mrsymbolIndex (Key key)
	Return the index portion of a symbol key. More...

unsigned char	mrsymbolLabel (Key key)
	Return the label portion of a symbol key. More...

template<class S , class V >
std::tuple< V, int >	nonlinearConjugateGradient (const S &system, const V &initial, const NonlinearOptimizerParams &params, const bool singleIteration, const DirectionMethod &directionMethod=DirectionMethod::PolakRibiere, const bool gradientDescent=false)

double	norm2 (const Point2 &p, OptionalJacobian< 1, 2 > H={})
	Distance of the point from the origin, with Jacobian. More...

double	norm3 (const Point3 &p, OptionalJacobian< 1, 3 > H={})
	Distance of the point from the origin, with Jacobian. More...

Unit3_	normal (const OrientedPlane3_ &p)

Point3	normalize (const Point3 &p, OptionalJacobian< 3, 3 > H={})
	normalize, with optional Jacobian More...

Point3_	normalize (const Point3_ &a)

static void	normalize (Signature::Row &row)

template<size_t d>
static size_t	NrUnknowns (const typename ShonanAveraging< d >::Measurements &measurements)

template<class Y , class X , int N = traits<X>::dimension>
internal::FixedSizeMatrix< Y, X >::type	numericalDerivative11 (std::function< Y(const X &)> h, const X &x, double delta=1e-5)
	New-style numerical derivatives using manifold_traits. More...

template<class Y , class X >
internal::FixedSizeMatrix< Y, X >::type	numericalDerivative11 (Y(*h)(const X &), const X &x, double delta=1e-5)

template<class Y , class X1 , class X2 , int N = traits<X1>::dimension>
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative21 (const std::function< Y(const X1 &, const X2 &)> &h, const X1 &x1, const X2 &x2, double delta=1e-5)

template<class Y , class X1 , class X2 >
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative21 (Y(*h)(const X1 &, const X2 &), const X1 &x1, const X2 &x2, double delta=1e-5)

template<class Y , class X1 , class X2 , int N = traits<X2>::dimension>
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative22 (std::function< Y(const X1 &, const X2 &)> h, const X1 &x1, const X2 &x2, double delta=1e-5)

template<class Y , class X1 , class X2 >
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative22 (Y(*h)(const X1 &, const X2 &), const X1 &x1, const X2 &x2, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , int N = traits<X1>::dimension>
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative31 (std::function< Y(const X1 &, const X2 &, const X3 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative31 (Y(*h)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , int N = traits<X2>::dimension>
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative32 (std::function< Y(const X1 &, const X2 &, const X3 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative32 (Y(*h)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , int N = traits<X3>::dimension>
internal::FixedSizeMatrix< Y, X3 >::type	numericalDerivative33 (std::function< Y(const X1 &, const X2 &, const X3 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< Y, X3 >::type	numericalDerivative33 (Y(*h)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X1>::dimension>
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative41 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 >
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative41 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X2>::dimension>
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative42 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 >
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative42 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X3>::dimension>
internal::FixedSizeMatrix< Y, X3 >::type	numericalDerivative43 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 >
internal::FixedSizeMatrix< Y, X3 >::type	numericalDerivative43 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X4>::dimension>
internal::FixedSizeMatrix< Y, X4 >::type	numericalDerivative44 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 >
internal::FixedSizeMatrix< Y, X4 >::type	numericalDerivative44 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X1>::dimension>
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative51 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative51 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X2>::dimension>
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative52 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative52 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X3>::dimension>
internal::FixedSizeMatrix< Y, X3 >::type	numericalDerivative53 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >
internal::FixedSizeMatrix< Y, X3 >::type	numericalDerivative53 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X4>::dimension>
internal::FixedSizeMatrix< Y, X4 >::type	numericalDerivative54 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >
internal::FixedSizeMatrix< Y, X4 >::type	numericalDerivative54 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X5>::dimension>
internal::FixedSizeMatrix< Y, X5 >::type	numericalDerivative55 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >
internal::FixedSizeMatrix< Y, X5 >::type	numericalDerivative55 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X1>::dimension>
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative61 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >
internal::FixedSizeMatrix< Y, X1 >::type	numericalDerivative61 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X2>::dimension>
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative62 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >
internal::FixedSizeMatrix< Y, X2 >::type	numericalDerivative62 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X3>::dimension>
internal::FixedSizeMatrix< Y, X3 >::type	numericalDerivative63 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >
internal::FixedSizeMatrix< Y, X3 >::type	numericalDerivative63 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X4>::dimension>
internal::FixedSizeMatrix< Y, X4 >::type	numericalDerivative64 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >
internal::FixedSizeMatrix< Y, X4 >::type	numericalDerivative64 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X5>::dimension>
internal::FixedSizeMatrix< Y, X5 >::type	numericalDerivative65 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >
internal::FixedSizeMatrix< Y, X5 >::type	numericalDerivative65 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X6>::dimension>
internal::FixedSizeMatrix< Y, X6 >::type	numericalDerivative66 (std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)> h, const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >
internal::FixedSizeMatrix< Y, X6 >::type	numericalDerivative66 (Y(*h)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &), const X1 &x1, const X2 &x2, const X3 &x3, const X4 &x4, const X5 &x5, const X6 &x6, double delta=1e-5)

template<class X , int N = traits<X>::dimension>
Eigen::Matrix< double, N, 1 >	numericalGradient (std::function< double(const X &)> h, const X &x, double delta=1e-5)
	Numerically compute gradient of scalar function. More...

template<class X >
internal::FixedSizeMatrix< X, X >::type	numericalHessian (double(*f)(const X &), const X &x, double delta=1e-5)

template<class X >
internal::FixedSizeMatrix< X, X >::type	numericalHessian (std::function< double(const X &)> f, const X &x, double delta=1e-5)

template<class X1 , class X2 >
internal::FixedSizeMatrix< X1, X1 >::type	numericalHessian211 (double(*f)(const X1 &, const X2 &), const X1 &x1, const X2 &x2, double delta=1e-5)

template<class X1 , class X2 >
internal::FixedSizeMatrix< X1, X1 >::type	numericalHessian211 (std::function< double(const X1 &, const X2 &)> f, const X1 &x1, const X2 &x2, double delta=1e-5)

template<class X1 , class X2 >
internal::FixedSizeMatrix< X1, X2 >::type	numericalHessian212 (double(*f)(const X1 &, const X2 &), const X1 &x1, const X2 &x2, double delta=1e-5)

template<class X1 , class X2 >
internal::FixedSizeMatrix< X1, X2 >::type	numericalHessian212 (std::function< double(const X1 &, const X2 &)> f, const X1 &x1, const X2 &x2, double delta=1e-5)

template<class X1 , class X2 >
internal::FixedSizeMatrix< X2, X2 >::type	numericalHessian222 (double(*f)(const X1 &, const X2 &), const X1 &x1, const X2 &x2, double delta=1e-5)

template<class X1 , class X2 >
internal::FixedSizeMatrix< X2, X2 >::type	numericalHessian222 (std::function< double(const X1 &, const X2 &)> f, const X1 &x1, const X2 &x2, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X1, X1 >::type	numericalHessian311 (double(*f)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X1, X1 >::type	numericalHessian311 (std::function< double(const X1 &, const X2 &, const X3 &)> f, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X1, X2 >::type	numericalHessian312 (double(*f)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X1, X2 >::type	numericalHessian312 (std::function< double(const X1 &, const X2 &, const X3 &)> f, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X1, X3 >::type	numericalHessian313 (double(*f)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X1, X3 >::type	numericalHessian313 (std::function< double(const X1 &, const X2 &, const X3 &)> f, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X2, X2 >::type	numericalHessian322 (double(*f)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X2, X2 >::type	numericalHessian322 (std::function< double(const X1 &, const X2 &, const X3 &)> f, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X2, X3 >::type	numericalHessian323 (double(*f)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X2, X3 >::type	numericalHessian323 (std::function< double(const X1 &, const X2 &, const X3 &)> f, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X3, X3 >::type	numericalHessian333 (double(*f)(const X1 &, const X2 &, const X3 &), const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

template<class X1 , class X2 , class X3 >
internal::FixedSizeMatrix< X3, X3 >::type	numericalHessian333 (std::function< double(const X1 &, const X2 &, const X3 &)> f, const X1 &x1, const X2 &x2, const X3 &x3, double delta=1e-5)

Pose3	openGL2gtsam (const Rot3 &R, double tx, double ty, double tz)
	This function converts an openGL camera pose to an GTSAM camera pose. More...

Rot3	openGLFixedRotation ()

bool	operator!= (const Matrix &A, const Matrix &B)

Signature	operator% (const DiscreteKey &key, const Signature::Table &parent)

GTSAM_EXPORT Signature	operator% (const DiscreteKey &key, const std::string &parent)

Signature	operator% (const DiscreteKey &key, const string &parent)

DiscreteKeys	operator& (const DiscreteKey &key1, const DiscreteKey &key2)
	Create a list from two keys. More...

VectorValues	operator* (const double a, const VectorValues &c)

template<typename T >
Expression< T >	operator* (const Expression< T > &expression1, const Expression< T > &expression2)
	Construct a product expression, assumes T::compose(T) -> T. More...

template<typename T >
ScalarMultiplyExpression< T >	operator* (double s, const Expression< T > &e)

Point2	operator* (double s, const Point2 &p)
	multiply with scalar More...

Errors	operator+ (const Errors &a, const Errors &b)
	Addition. More...

template<typename T >
BinarySumExpression< T >	operator+ (const Expression< T > &e1, const Expression< T > &e2)

HybridGaussianProductFactor	operator+ (const HybridGaussianProductFactor &a, const HybridGaussianProductFactor &b)

Errors	operator- (const Errors &a)
	Negation. More...

Errors	operator- (const Errors &a, const Errors &b)
	Subtraction. More...

template<typename T >
BinarySumExpression< T >	operator- (const Expression< T > &e1, const Expression< T > &e2)
	Construct an expression that subtracts one expression from another. More...

ostream &	operator<< (ostream &os, const EssentialMatrix &E)

ostream &	operator<< (ostream &os, const gtsam::Point2Pair &p)

ostream &	operator<< (ostream &os, const gtsam::Point3Pair &p)

ostream &	operator<< (ostream &os, const IterativeOptimizationParameters &p)

ostream &	operator<< (ostream &os, const key_formatter &m)

ostream &	operator<< (ostream &os, const PreconditionerParameters &p)

ostream &	operator<< (ostream &os, const PreintegrationBase &pim)

ostream &	operator<< (ostream &os, const Rot3 &R)

ostream &	operator<< (ostream &os, const Signature &s)

ostream &	operator<< (ostream &os, const Signature::Row &row)

ostream &	operator<< (ostream &os, const Signature::Table &table)

ostream &	operator<< (ostream &os, const StereoPoint2 &p)

ostream &	operator<< (ostream &os, const StreamedKey &streamedKey)

ostream &	operator<< (ostream &os, const Subgraph &subgraph)

ostream &	operator<< (ostream &os, const Subgraph::Edge &edge)

ostream &	operator<< (ostream &os, const SubgraphBuilderParameters &p)

std::ostream &	operator<< (std::ostream &os, const Cal3 &cal)

std::ostream &	operator<< (std::ostream &os, const Cal3_S2 &cal)

std::ostream &	operator<< (std::ostream &os, const Cal3_S2Stereo &cal)

std::ostream &	operator<< (std::ostream &os, const Cal3Bundler &cal)

std::ostream &	operator<< (std::ostream &os, const Cal3DS2 &cal)

std::ostream &	operator<< (std::ostream &os, const Cal3DS2_Base &cal)

std::ostream &	operator<< (std::ostream &os, const Cal3f &cal)

std::ostream &	operator<< (std::ostream &os, const Cal3Fisheye &cal)

std::ostream &	operator<< (std::ostream &os, const Cal3Unified &cal)

std::ostream &	operator<< (std::ostream &os, const CombinedImuFactor &f)

std::ostream &	operator<< (std::ostream &os, const Dih6 &m)

GTSAM_EXPORT std::ostream &	operator<< (std::ostream &os, const EdgeKey &key)

GTSAM_EXPORT std::ostream &	operator<< (std::ostream &os, const gtsam::Point2Pair &p)

GTSAM_EXPORT std::ostream &	operator<< (std::ostream &os, const gtsam::Point3Pair &p)

std::ostream &	operator<< (std::ostream &os, const ImuFactor &f)

std::ostream &	operator<< (std::ostream &os, const ImuFactor2 &f)

GTSAM_EXPORT std::ostream &	operator<< (std::ostream &os, const LabeledSymbol &symbol)

std::ostream &	operator<< (std::ostream &os, const NavState &state)

std::ostream &	operator<< (std::ostream &os, const Pose2 &pose)

std::ostream &	operator<< (std::ostream &os, const Pose3 &pose)

std::ostream &	operator<< (std::ostream &os, const Similarity2 &p)

std::ostream &	operator<< (std::ostream &os, const Similarity3 &p)

GTSAM_EXPORT std::ostream &	operator<< (std::ostream &os, const Symbol &symbol)

std::ostream &	operator<< (std::ostream &os, const Unit3 &pair)

GTSAM_EXPORT std::ostream &	operator<< (std::ostream &os, const VectorValues &v)

std::ostream &	operator<< (std::ostream &stream, const ImuMeasurement &meas)

bool	operator== (const Matrix &A, const Matrix &B)

bool	operator== (const Vector &vec1, const Vector &vec2)

istream &	operator>> (istream &inputStream, Matrix &destinationMatrix)

istream &	operator>> (istream &is, EssentialMatrix &E)

GTSAM_EXPORT std::istream &	operator>> (std::istream &inputStream, Matrix &destinationMatrix)

std::istream &	operator>> (std::istream &is, GaussianFactorGraphValuePair &pair)

std::istream &	operator>> (std::istream &is, Matrix6 &m)

std::istream &	operator>> (std::istream &is, Quaternion &q)

std::istream &	operator>> (std::istream &is, Rot3 &R)

Vector	operator^ (const Matrix &A, const Vector &v)

Signature	operator\| (const DiscreteKey &key, const DiscreteKey &parent)

Point3	optimize (const NonlinearFactorGraph &graph, const Values &values, Key landmarkKey)

size_t	optimizeWildfire (const ISAM2Clique::shared_ptr &root, double threshold, const KeySet &keys, VectorValues *delta)

size_t	optimizeWildfireNonRecursive (const ISAM2Clique::shared_ptr &root, double threshold, const KeySet &keys, VectorValues *delta)

FastVector< VariableSlots::const_iterator >	orderedSlotsHelper (const Ordering &ordering, const VariableSlots &variableSlots)

BetweenFactorPose2s	parse2DFactors (const std::string &filename, const noiseModel::Diagonal::shared_ptr &model, size_t maxIndex)

BetweenFactorPose3s	parse3DFactors (const std::string &filename, const noiseModel::Diagonal::shared_ptr &model, size_t maxIndex)

static Table	ParseAnd ()

static std::optional< Row >	ParseConditional (const std::string &token)

static std::optional< Table >	ParseConditionalTable (const std::vector< std::string > &tokens)

std::optional< IndexedEdge >	parseEdge (std::istream &is, const std::string &tag)

template<typename T >
GTSAM_EXPORT std::vector< typename BetweenFactor< T >::shared_ptr >	parseFactors (const std::string &filename, const noiseModel::Diagonal::shared_ptr &model=nullptr, size_t maxIndex=0)

template<>
GTSAM_EXPORT std::vector< BetweenFactor< Pose2 >::shared_ptr >	parseFactors< Pose2 > (const std::string &filename, const noiseModel::Diagonal::shared_ptr &model, size_t maxIndex)

template<>
GTSAM_EXPORT std::vector< BetweenFactor< Pose3 >::shared_ptr >	parseFactors< Pose3 > (const std::string &filename, const noiseModel::Diagonal::shared_ptr &model, size_t maxIndex)

static Row	ParseFalseRow ()

template<typename T >
static void	parseLines (const std::string &filename, Parser< T > parse)

template<>
GTSAM_EXPORT std::vector< BinaryMeasurement< Pose2 > >	parseMeasurements (const std::string &filename, const noiseModel::Diagonal::shared_ptr &model, size_t maxIndex)

static Table	ParseOr ()

template<typename T >
std::map< size_t, T >	parseToMap (const std::string &filename, Parser< std::pair< size_t, T >> parse, size_t maxIndex)

template<typename T >
static std::vector< T >	parseToVector (const std::string &filename, Parser< T > parse)

static Row	ParseTrueRow ()

template<typename T >
GTSAM_EXPORT std::map< size_t, T >	parseVariables (const std::string &filename, size_t maxIndex=0)

template<>
GTSAM_EXPORT std::map< size_t, Point2 >	parseVariables< Point2 > (const std::string &filename, size_t maxIndex)

template<>
GTSAM_EXPORT std::map< size_t, Point3 >	parseVariables< Point3 > (const std::string &filename, size_t maxIndex)

template<>
GTSAM_EXPORT std::map< size_t, Pose2 >	parseVariables< Pose2 > (const std::string &filename, size_t maxIndex)

template<>
GTSAM_EXPORT std::map< size_t, Pose3 >	parseVariables< Pose3 > (const std::string &filename, size_t maxIndex)

std::optional< IndexedLandmark >	parseVertexLandmark (std::istream &is, const std::string &tag)

std::optional< std::pair< size_t, Point3 > >	parseVertexPoint3 (std::istream &is, const std::string &tag)

std::optional< IndexedPose >	parseVertexPose (std::istream &is, const std::string &tag)

std::optional< std::pair< size_t, Pose3 > >	parseVertexPose3 (std::istream &is, const std::string &tag)

static Vector	perturb (const Vector &initialVector)

Point3_	point3 (const Unit3_ &v)

template<typename Gradient >
double	PolakRibiere (const Gradient &currentGradient, const Gradient &prevGradient)
	Polak-Ribiere formula for computing β, the direction of steepest descent. More...

std::vector< Pose3 >	posesOnCircle (int num_cameras=8, double R=30)

Point3_	position (const NavState_ &X)

static double	PotentiallyPrunedComponentError (const GaussianFactorValuePair &pair, const VectorValues &continuousValues)

static bool	PowerMinimumEigenValue (const Sparse &A, const Matrix &S, double &minEigenValue, Vector minEigenVector=0, size_t numIterations=0, size_t maxIterations=1000, double minEigenvalueNonnegativityTolerance=10e-4)
	MINIMUM EIGENVALUE COMPUTATIONS. More...

template<class S , class V >
V	preconditionedConjugateGradient (const S &system, const V &initial, const ConjugateGradientParameters &parameters)

template<class G , class V , class KEY >
std::tuple< G, V, std::map< KEY, V > >	predecessorMap2Graph (const PredecessorMap< KEY > &p_map)

template<class KEY >
std::list< KEY >	predecessorMap2Keys (const PredecessorMap< KEY > &p_map)

template<class CONTAINER >
void	Print (const CONTAINER &keys, const string &s, const KeyFormatter &keyFormatter)

GTSAM_EXPORT void	print (const Errors &e, const std::string &s="Errors")
	Print an Errors instance. More...

void	print (const Errors &e, const string &s)
	Print an Errors instance. More...

GTSAM_EXPORT void	print (const Matrix &A, const std::string &s, std::ostream &stream)

GTSAM_EXPORT void	print (const Matrix &A, const std::string &s="")

void	print (const Matrix &A, const string &s)

void	print (const Matrix &A, const string &s, ostream &stream)

GTSAM_EXPORT void	print (const Vector &v, const std::string &s, std::ostream &stream)

GTSAM_EXPORT void	print (const Vector &v, const std::string &s="")

void	print (const Vector &v, const string &s)

void	print (const Vector &v, const string &s, ostream &stream)

void	print (double v, const std::string &s="")

void	print (float v, const std::string &s="")

static void	printFactor (const std::shared_ptr< Factor > &factor, const DiscreteValues &assignment, const KeyFormatter &keyFormatter)

GTSAM_EXPORT void	PrintKey (Key key, const std::string &s="", const KeyFormatter &keyFormatter=DefaultKeyFormatter)
	Utility function to print one key with optional prefix. More...

void	PrintKey (Key key, const string &s, const KeyFormatter &keyFormatter)
	Utility function to print one key with optional prefix. More...

GTSAM_EXPORT void	PrintKeyList (const KeyList &keys, const std::string &s="", const KeyFormatter &keyFormatter=DefaultKeyFormatter)
	Utility function to print sets of keys with optional prefix. More...

void	PrintKeyList (const KeyList &keys, const string &s, const KeyFormatter &keyFormatter)
	Utility function to print sets of keys with optional prefix. More...

GTSAM_EXPORT void	PrintKeySet (const KeySet &keys, const std::string &s="", const KeyFormatter &keyFormatter=DefaultKeyFormatter)
	Utility function to print sets of keys with optional prefix. More...

void	PrintKeySet (const KeySet &keys, const string &s, const KeyFormatter &keyFormatter)
	Utility function to print sets of keys with optional prefix. More...

GTSAM_EXPORT void	PrintKeyVector (const KeyVector &keys, const std::string &s="", const KeyFormatter &keyFormatter=DefaultKeyFormatter)
	Utility function to print sets of keys with optional prefix. More...

void	PrintKeyVector (const KeyVector &keys, const string &s, const KeyFormatter &keyFormatter)
	Utility function to print sets of keys with optional prefix. More...

template<class MATRIX >
MATRIX	prod (const MATRIX &A, const MATRIX &B)

Point2_	project (const Point3_ &p_cam)
	Expression version of PinholeBase::Project. More...

Point2_	project (const Unit3_ &p_cam)

template<class CAMERA , class POINT >
Point2_	project2 (const Expression< CAMERA > &camera_, const Expression< POINT > &p_)

template<class CALIBRATION , class POINT >
Point2_	project3 (const Pose3_ &x, const Expression< POINT > &p, const Expression< CALIBRATION > &K)

template<class CAMERA >
std::vector< Matrix34, Eigen::aligned_allocator< Matrix34 > >	projectionMatricesFromCameras (const CameraSet< CAMERA > &cameras)

template<class CALIBRATION >
std::vector< Matrix34, Eigen::aligned_allocator< Matrix34 > >	projectionMatricesFromPoses (const std::vector< Pose3 > &poses, std::shared_ptr< CALIBRATION > sharedCal)

pair< Matrix, Matrix >	qr (const Matrix &A)

Double_	range (const Point2_ &p, const Point2_ &q)

SfmData	readBal (const std::string &filename)
	This function parses a "Bundle Adjustment in the Large" (BAL) file and returns the data as a SfmData structure. Mainly used by wrapped code. More...

GraphAndValues	readG2o (const std::string &g2oFile, const bool is3D=false, KernelFunctionType kernelFunctionType=KernelFunctionTypeNONE)
	This function parses a g2o file and stores the measurements into a NonlinearFactorGraph and the initial guess in a Values structure. More...

void	recursiveMarkAffectedKeys (const Key &key, const ISAM2Clique::shared_ptr &clique, std::set< Key > &additionalKeys)

template<int OutM, int OutN, int OutOptions, int InM, int InN, int InOptions>
Reshape< OutM, OutN, OutOptions, InM, InN, InOptions >::ReshapedType	reshape (const Eigen::Matrix< double, InM, InN, InOptions > &m)

Point3_	rotate (const Rot3_ &x, const Point3_ &p)

Unit3_	rotate (const Rot3_ &x, const Unit3_ &p)

Rot3_	rotation (const Pose3_ &pose)

template<size_t d>
static Matrix	RoundSolutionS (const Matrix &S)

template<class MATRIX >
const MATRIX::ConstRowXpr	row (const MATRIX &A, size_t j)

pair< Matrix3, Vector3 >	RQ (const Matrix3 &A, OptionalJacobian< 3, 9 > H)

Matrix	RtR (const Matrix &A)

GTSAM_EXPORT void	save (const Matrix &A, const std::string &s, const std::string &filename)

void	save (const Matrix &A, const string &s, const string &filename)

GTSAM_EXPORT void	save (const Vector &A, const std::string &s, const std::string &filename)

void	save (const Vector &v, const string &s, const string &filename)

void	save2D (const NonlinearFactorGraph &graph, const Values &config, const noiseModel::Diagonal::shared_ptr model, const std::string &filename)

static double	scale (double x, double a, double b, double t1, double t2)
	Scale x from [a, b] to [t1, t2]. More...

static Scatter	scatterFromValues (const Values &values)

static Scatter	scatterFromValues (const Values &values, const Ordering &ordering)

std::string	serializeGraph (const NonlinearFactorGraph &graph)

bool	serializeGraphToFile (const NonlinearFactorGraph &graph, const std::string &fname)

bool	serializeGraphToXMLFile (const NonlinearFactorGraph &graph, const std::string &fname, const std::string &name="graph")

std::string	serializeGraphXML (const NonlinearFactorGraph &graph, const std::string &name="graph")

std::string	serializeValues (const Values &values)

bool	serializeValuesToFile (const Values &values, const std::string &fname)

bool	serializeValuesToXMLFile (const Values &values, const std::string &fname, const std::string &name="values")

std::string	serializeValuesXML (const Values &values, const std::string &name="values")

static void	setSubvector (const Vector &src, const KeyInfo &keyInfo, const KeyVector &keys, Vector &dst)

template<class Derived >
Matrix3	skewSymmetric (const Eigen::MatrixBase< Derived > &w)

Matrix3	skewSymmetric (double wx, double wy, double wz)

SparseEigen	sparseJacobianEigen (const GaussianFactorGraph &gfg)

SparseEigen	sparseJacobianEigen (const GaussianFactorGraph &gfg, const Ordering &ordering)
	Constructs an Eigen-format SparseMatrix of a GaussianFactorGraph. More...

static bool	SparseMinimumEigenValue (const Sparse &A, const Matrix &S, double minEigenValue, Vector minEigenVector=0, size_t *numIterations=0, size_t maxIterations=1000, double minEigenvalueNonnegativityTolerance=10e-4, Eigen::Index numLanczosVectors=20)

template<class G , class KEY , class FACTOR2 >
void	split (const G &g, const PredecessorMap< KEY > &tree, G &Ab1, G &Ab2)

std::pair< GaussianFactorGraph, GaussianFactorGraph >	splitFactorGraph (const GaussianFactorGraph &factorGraph, const Subgraph &subgraph)

Matrix	stack (const std::vector< Matrix > &blocks)

Matrix	stack (size_t nrMatrices,...)

VectorValues	steepestDescent (const GaussianFactorGraph &fg, const VectorValues &x, const ConjugateGradientParameters &parameters)

Vector	steepestDescent (const Matrix &A, const Vector &b, const Vector &x, const ConjugateGradientParameters &parameters)

Vector	steepestDescent (const System &Ab, const Vector &x, const ConjugateGradientParameters &parameters)

GTSAM_EXPORT Vector	steepestDescent (const System &Ab, const Vector &x, const IterativeOptimizationParameters &parameters)

GTSAM_EXPORT Matrix43	stiefel (const SO4 &Q, OptionalJacobian< 12, 6 > H)

static void	streamSignature (const DiscreteConditional &conditional, const KeyFormatter &keyFormatter, stringstream *ss)

template<class MATRIX >
Eigen::Block< const MATRIX >	sub (const MATRIX &A, size_t i1, size_t i2, size_t j1, size_t j2)

void	svd (const Matrix &A, Matrix &U, Vector &S, Matrix &V)

Key	symbol (unsigned char c, std::uint64_t j)

unsigned char	symbolChr (Key key)

std::uint64_t	symbolIndex (Key key)

void	synchronize (ConcurrentFilter &filter, ConcurrentSmoother &smoother)

	TEST (LPInitSolver, InfiniteLoopMultiVar)

	TEST (LPInitSolver, InfiniteLoopSingleVar)

	TEST (LPInitSolver, Initialization)

	TEST (SmartFactorBase, Pinhole)

	TEST (SmartFactorBase, PinholeWithSensor)

	TEST (SmartFactorBase, Stereo)

template<typename G >
void	testChartDerivatives (TestResult &result_, const std::string &name_, const G &t1, const G &t2)

template<typename T >
void	testDefaultChart (TestResult &result_, const std::string &name_, const T &value)

template<typename G >
void	testLieGroupDerivatives (TestResult &result_, const std::string &name_, const G &t1, const G &t2)

static void	throwRuntimeError (const std::string &s, const std::shared_ptr< Factor > &f)

void	tictoc_finishedIteration_ ()

void	tictoc_print2_ ()

void	tictoc_print_ ()

void	tictoc_reset_ ()

template<class G , class F , class KEY >
SDGraph< KEY >	toBoostGraph (const G &graph)

static std::vector< std::string >	Tokenize (const std::string &str)

GTSAM_EXPORT Matrix3	topLeft (const SO4 &Q, OptionalJacobian< 9, 6 > H)

Matrix	trans (const Matrix &A)

template<class T , class P >
P	transform_point (const T &trans, const P &global, OptionalMatrixType Dtrans, OptionalMatrixType Dglobal)

Point3_	transformFrom (const Pose3_ &x, const Point3_ &p)

Pose3_	transformPoseTo (const Pose3_ &p, const Pose3_ &q)

Point2_	transformTo (const Pose2_ &x, const Point2_ &p)

Line3	transformTo (const Pose3 &wTc, const Line3 &wL, OptionalJacobian< 4, 6 > Dpose, OptionalJacobian< 4, 4 > Dline)

Line3_	transformTo (const Pose3_ &wTc, const Line3_ &wL)

Point3_	transformTo (const Pose3_ &x, const Point3_ &p)

Point3_	translation (const Pose3_ &pose)

Point3	triangulateDLT (const std::vector< Matrix34, Eigen::aligned_allocator< Matrix34 >> &projection_matrices, const Point2Vector &measurements, double rank_tol)

Point3	triangulateDLT (const std::vector< Matrix34, Eigen::aligned_allocator< Matrix34 >> &projection_matrices, const std::vector< Unit3 > &measurements, double rank_tol)

Vector4	triangulateHomogeneousDLT (const std::vector< Matrix34, Eigen::aligned_allocator< Matrix34 >> &projection_matrices, const Point2Vector &measurements, double rank_tol)

Vector4	triangulateHomogeneousDLT (const std::vector< Matrix34, Eigen::aligned_allocator< Matrix34 >> &projection_matrices, const std::vector< Unit3 > &measurements, double rank_tol)

Point3	triangulateLOST (const std::vector< Pose3 > &poses, const Point3Vector &calibratedMeasurements, const SharedIsotropic &measurementNoise, double rank_tol=1e-9)
	Triangulation using the LOST (Linear Optimal Sine Triangulation) algorithm proposed in https://arxiv.org/pdf/2205.12197.pdf by Sebastien Henry and John Christian. More...

template<class CAMERA >
Point3	triangulateNonlinear (const CameraSet< CAMERA > &cameras, const typename CAMERA::MeasurementVector &measurements, const Point3 &initialEstimate, const SharedNoiseModel &model=nullptr)

template<class CALIBRATION >
Point3	triangulateNonlinear (const std::vector< Pose3 > &poses, std::shared_ptr< CALIBRATION > sharedCal, const Point2Vector &measurements, const Point3 &initialEstimate, const SharedNoiseModel &model=nullptr)

template<class CAMERA >
Point3	triangulatePoint3 (const CameraSet< CAMERA > &cameras, const typename CAMERA::MeasurementVector &measurements, double rank_tol=1e-9, bool optimize=false, const SharedNoiseModel &model=nullptr, const bool useLOST=false)

template<class CALIBRATION >
Point3	triangulatePoint3 (const CameraSet< PinholeCamera< CALIBRATION >> &cameras, const Point2Vector &measurements, double rank_tol=1e-9, bool optimize=false, const SharedNoiseModel &model=nullptr, const bool useLOST=false)
	Pinhole-specific version. More...

template<class CALIBRATION >
Point3	triangulatePoint3 (const std::vector< Pose3 > &poses, std::shared_ptr< CALIBRATION > sharedCal, const Point2Vector &measurements, double rank_tol=1e-9, bool optimize=false, const SharedNoiseModel &model=nullptr, const bool useLOST=false)

template<class CAMERA >
TriangulationResult	triangulateSafe (const CameraSet< CAMERA > &cameras, const typename CAMERA::MeasurementVector &measured, const TriangulationParameters &params)
	triangulateSafe: extensive checking of the outcome More...

template<class CAMERA >
std::pair< NonlinearFactorGraph, Values >	triangulationGraph (const CameraSet< CAMERA > &cameras, const typename CAMERA::MeasurementVector &measurements, Key landmarkKey, const Point3 &initialEstimate, const SharedNoiseModel &model=nullptr)

template<class CALIBRATION >
std::pair< NonlinearFactorGraph, Values >	triangulationGraph (const std::vector< Pose3 > &poses, std::shared_ptr< CALIBRATION > sharedCal, const Point2Vector &measurements, Key landmarkKey, const Point3 &initialEstimate, const SharedNoiseModel &model=noiseModel::Unit::Create(2))

template<class CALIBRATION >
Point2_	uncalibrate (const Expression< CALIBRATION > &K, const Point2_ &xy_hat)

template<class CALIBRATION , class MEASUREMENT >
MEASUREMENT	undistortMeasurementInternal (const CALIBRATION &cal, const MEASUREMENT &measurement, std::optional< Cal3_S2 > pinholeCal={})

template<>
Point2Vector	undistortMeasurements (const Cal3_S2 &cal, const Point2Vector &measurements)

template<class CALIBRATION >
Point2Vector	undistortMeasurements (const CALIBRATION &cal, const Point2Vector &measurements)

template<class CAMERA >
CAMERA::MeasurementVector	undistortMeasurements (const CameraSet< CAMERA > &cameras, const typename CAMERA::MeasurementVector &measurements)

template<class CAMERA = PinholeCamera<Cal3_S2>>
PinholeCamera< Cal3_S2 >::MeasurementVector	undistortMeasurements (const CameraSet< PinholeCamera< Cal3_S2 >> &cameras, const PinholeCamera< Cal3_S2 >::MeasurementVector &measurements)

template<class CAMERA = SphericalCamera>
SphericalCamera::MeasurementVector	undistortMeasurements (const CameraSet< SphericalCamera > &cameras, const SphericalCamera::MeasurementVector &measurements)

Point3_	unrotate (const Rot3_ &x, const Point3_ &p)

Unit3_	unrotate (const Rot3_ &x, const Unit3_ &p)

template<typename L , typename T1 , typename T2 >
std::pair< DecisionTree< L, T1 >, DecisionTree< L, T2 > >	unzip (const DecisionTree< L, std::pair< T1, T2 > > &input)
	unzip a DecisionTree with `std::pair` values. More...

static std::string	valueFormatter (const double &v)

static Vector9	vec3 (const Matrix3 &R)

static SO4::VectorN2	vec4 (const Matrix4 &Q)

Matrix	vector_scale (const Matrix &A, const Vector &v, bool inf_mask)

Matrix	vector_scale (const Vector &v, const Matrix &A, bool inf_mask)

void	vector_scale_inplace (const Vector &v, Matrix &A, bool inf_mask)

Velocity3_	velocity (const NavState_ &X)

template<class T >
Matrix	wedge (const Vector &x)

template<>
Matrix	wedge< Pose2 > (const Vector &xi)

template<>
Matrix	wedge< Pose3 > (const Vector &xi)

template<>
Matrix	wedge< Similarity3 > (const Vector &xi)

list< std::tuple< Vector, double, double > >	weighted_eliminate (Matrix &A, Vector &b, const Vector &sigmas)

pair< Vector, double >	weightedPseudoinverse (const Vector &a, const Vector &weights)

double	weightedPseudoinverse (const Vector &a, const Vector &weights, Vector &pseudo)

bool	writeBAL (const std::string &filename, const SfmData &data)
	This function writes a "Bundle Adjustment in the Large" (BAL) file from a SfmData structure. More...

bool	writeBALfromValues (const std::string &filename, const SfmData &data, const Values &values)
	This function writes a "Bundle Adjustment in the Large" (BAL) file from a SfmData structure and a value structure (measurements are the same as the SfM input data, while camera poses and values are read from Values) More...

void	writeG2o (const NonlinearFactorGraph &graph, const Values &estimate, const std::string &filename)
	This function writes a g2o file from NonlinearFactorGraph and a Values structure. More...

template<class MATRIX >
void	zeroBelowDiagonal (MATRIX &A, size_t cols=0)

Variables
const G &	b

static const size_t	chrBits = sizeof(unsigned char) * 8

static const Key	chrMask = Key(UCHAR_MAX) << indexBits

template class GTSAM_EXPORT	Conditional< DecisionTreeFactor, DiscreteConditional >

GTSAM_EXPORT FastMap< std::string, ValueWithDefault< bool, false > >	debugFlags

KeyFormatter	DefaultKeyFormatter = &_defaultKeyFormatter
	Assign default key formatter. More...

static size_t	gDummyCount = 0

static auto	GetDiscreteKeys
	Get the discrete keys from the HybridGaussianFactorGraph as DiscreteKeys. More...

static const size_t	indexBits = keyBits - chrBits

static const Key	indexMask = ~chrMask

static double	intNoiseVar = 0.0000001

static const VectorValues	kEmpty

static const size_t	keyBits = sizeof(Key) * 8

	KeypointsVector = list

static const Vector	kGravity = Vector::Unit(3,2)*9.81

static const size_t	kHeightIndex = 5

static const Matrix3	kIntegrationErrorCovariance = intNoiseVar * I_3x3

static const size_t	kPitchIndex = 1

static const size_t	kRollIndex = 0

static const std::vector< size_t >	kVelocityIndices = { 6, 7, 8 }

static const size_t	kVelocityZIndex = 8

const double	logSqrt2PI = log(std::sqrt(2.0 * M_PI))
	constant needed below More...

	MatchIndicesMap = dict

const size_t	max_it = 100000

static const gtsam::KeyFormatter	MultiRobotKeyFormatter

static const double	negativePivotThreshold = -1e-1

static const Matrix93	P3

static const Eigen::Matrix< double, 16, 6 >	P4

static const Rot2	R_PI_2 (Rot2::fromCosSin(0., 1.))

	SfmCameras = list

	SfmMeasurementVector = list

	SfmTracks = list

const G double	tol

static const int	underconstrainedExponentDifference = 12

static const double	underconstrainedPrior = 1e-5

static const Eigen::MatrixBase< Vector2 >::ConstantReturnType	Z_2x1 = Vector2::Zero()

static const Eigen::MatrixBase< Vector3 >::ConstantReturnType	Z_3x1 = Vector3::Zero()

static const double	zeroPivotThreshold = 1e-6

Detailed Description

traits

A structure-from-motion example with landmarks, default arguments give:

The landmarks form a 10 meter cube
The robot rotates around the landmarks, always facing towards the cube Passing function argument allows to specify an initial position, a pose increment and step count.

Global functions in a separate testing namespace

These should not be used outside of tests, as they are just remappings of the original functions. We use these to avoid needing to do too much std::bind magic or writing a bunch of separate proxy functions.

Don't expect all classes to work for all of these functions.

Matrix is a typedef in the gtsam namespace TODO: make a version to work with matlab wrapping we use the default < double,col_major,unbounded_array<double> >

This file supports creating continuous functions f(x;p) as a linear combination of basis functions such as the Fourier basis on SO(2) or a set of Chebyshev polynomials on [-1,1].

In the expression f(x;p) the variable x is the continuous argument at which the function is evaluated, and p are the parameters which are coefficients of the different basis functions, e.g. p = [4; 3; 2] => 4 + 3x + 2x^2 for a polynomial. However, different parameterizations are also possible.

The Basis class below defines a number of functors that can be used to evaluate f(x;p) at a given x, and these functors also calculate the Jacobian of f(x;p) with respect to the parameters p. This is actually the most important calculation, as it will allow GTSAM to optimize over the parameters p.

This functionality is implemented using the CRTP or "Curiously recurring template pattern" C++ idiom, which is a meta-programming technique in which the derived class is passed as a template argument to Basis<DERIVED>. The DERIVED class is assumed to satisfy a C++ concept, i.e., we expect it to define the following types and methods:

type Parameters: the parameters p in f(x;p)
CalculateWeights(size_t N, double x, double a=default, double b=default)
DerivativeWeights(size_t N, double x, double a=default, double b=default)

where Weights is an N*1 row vector which defines the basis values for the polynomial at the specified point x.

E.g. A Fourier series would give the following:

CalculateWeights -> For N=5, the values for the bases: [1, cos(x), sin(x), cos(2x), sin(2x)]
DerivativeWeights -> For N=5, these are: [0, -sin(x), cos(x), -2sin(2x), 2cos(x)]

Note that for a pseudo-spectral basis (as in Chebyshev2), the weights are instead the values for the Barycentric interpolation formula, since the values at the polynomial points (e.g. Chebyshev points) define the bases.

triangulationFactor.h

Date: March 2, 2014

Author: Frank Dellaert

Module definition file for GTSAM

Typedef Documentation

◆ base_grammar

typedef qi::grammar<boost::spirit::basic_istream_iterator<char> > gtsam::base_grammar

Definition at line 409 of file QPSParser.cpp.

◆ BearingRange2D

using gtsam::BearingRange2D = typedef BearingRange<Pose2, Point2>

Definition at line 450 of file dataset.cpp.

◆ BetweenFactorPose2s

gtsam::BetweenFactorPose2s = list

Definition at line 212 of file dataset.h.

◆ BetweenFactorPose3s

gtsam::BetweenFactorPose3s = list

Definition at line 218 of file dataset.h.

◆ BinaryMeasurementsPoint3

gtsam::BinaryMeasurementsPoint3 = list

Definition at line 225 of file dataset.h.

◆ BinaryMeasurementsRot3

gtsam::BinaryMeasurementsRot3 = list

Definition at line 226 of file dataset.h.

◆ BinaryMeasurementsUnit3

gtsam::BinaryMeasurementsUnit3 = list

Definition at line 224 of file dataset.h.

◆ Cal3_S2_

typedef Expression<Cal3_S2> gtsam::Cal3_S2_

Definition at line 127 of file slam/expressions.h.

◆ Cal3Bundler_

typedef Expression<Cal3Bundler> gtsam::Cal3Bundler_

Definition at line 128 of file slam/expressions.h.

◆ Camera

typedef PinholeCamera<Cal3Bundler0> gtsam::Camera

Definition at line 52 of file testAdaptAutoDiff.cpp.

◆ CameraSetCal3_S2

using gtsam::CameraSetCal3_S2 = typedef CameraSet<PinholeCamera<Cal3_S2> >

Definition at line 758 of file triangulation.h.

◆ CameraSetCal3Bundler

using gtsam::CameraSetCal3Bundler = typedef CameraSet<PinholeCamera<Cal3Bundler> >

Definition at line 757 of file triangulation.h.

◆ CameraSetCal3DS2

using gtsam::CameraSetCal3DS2 = typedef CameraSet<PinholeCamera<Cal3DS2> >

Definition at line 759 of file triangulation.h.

◆ CameraSetCal3Fisheye

using gtsam::CameraSetCal3Fisheye = typedef CameraSet<PinholeCamera<Cal3Fisheye> >

Definition at line 760 of file triangulation.h.

◆ CameraSetCal3Unified

using gtsam::CameraSetCal3Unified = typedef CameraSet<PinholeCamera<Cal3Unified> >

Definition at line 761 of file triangulation.h.

◆ CameraSetSpherical

using gtsam::CameraSetSpherical = typedef CameraSet<SphericalCamera>

Definition at line 762 of file triangulation.h.

◆ ConcurrentBatchFilterResult

typedef ConcurrentBatchFilter::Result gtsam::ConcurrentBatchFilterResult

Typedef for Matlab wrapping.

Definition at line 254 of file ConcurrentBatchFilter.h.

◆ ConcurrentBatchSmootherResult

typedef ConcurrentBatchSmoother::Result gtsam::ConcurrentBatchSmootherResult

Typedef for Matlab wrapping.

Definition at line 205 of file ConcurrentBatchSmoother.h.

◆ ConcurrentIncrementalFilterResult

typedef ConcurrentIncrementalFilter::Result gtsam::ConcurrentIncrementalFilterResult

Typedef for Matlab wrapping.

Definition at line 199 of file ConcurrentIncrementalFilter.h.

◆ ConcurrentIncrementalSmootherResult

typedef ConcurrentIncrementalSmoother::Result gtsam::ConcurrentIncrementalSmootherResult

Typedef for Matlab wrapping.

Definition at line 169 of file ConcurrentIncrementalSmoother.h.

◆ ConstSubMatrix

typedef Eigen::Block<const Matrix> gtsam::ConstSubMatrix

Definition at line 70 of file base/Matrix.h.

◆ ConstSubVector

typedef Eigen::VectorBlock<const Vector> gtsam::ConstSubVector

Definition at line 66 of file Vector.h.

◆ CustomErrorFunction

using gtsam::CustomErrorFunction = typedef std::function<Vector(const CustomFactor &, const Values &, const JacobianVector *)>

Definition at line 36 of file CustomFactor.h.

◆ DenseIndex

typedef ptrdiff_t gtsam::DenseIndex

The index type for Eigen objects.

Definition at line 103 of file types.h.

◆ Dih6

typedef DirectProduct<S2, S3> gtsam::Dih6

Definition at line 107 of file testGroup.cpp.

◆ Dims

typedef std::vector< Key > gtsam::Dims

Definition at line 41 of file HessianFactor.cpp.

◆ DiscreteCluster

using gtsam::DiscreteCluster = typedef DiscreteJunctionTree::Cluster

typedef for wrapper:

Definition at line 70 of file DiscreteJunctionTree.h.

◆ Domains

using gtsam::Domains = typedef std::map<Key, Domain>

Definition at line 29 of file Constraint.h.

◆ Double_

typedef Expression<double> gtsam::Double_

Definition at line 28 of file nonlinear/expressions.h.

◆ DSFInt

typedef DSF<int> gtsam::DSFInt

Definition at line 210 of file DSF.h.

◆ DSFMapIndexPair

typedef DSFMap<IndexPair> gtsam::DSFMapIndexPair

Definition at line 131 of file DSFMap.h.

◆ DynamicJacobian

using gtsam::DynamicJacobian = typedef OptionalJacobian<Eigen::Dynamic, Eigen::Dynamic>

Definition at line 363 of file SOn.h.

◆ enable_if_t

template<bool B, class T = void>

using gtsam::enable_if_t = typedef typename std::enable_if<B, T>::type

An shorthand alias for accessing the ::type inside std::enable_if that can be used in a template directly.

Definition at line 30 of file make_shared.h.

◆ Errors

using gtsam::Errors = typedef FastList<Vector>

Errors is a vector of errors.

Definition at line 34 of file Errors.h.

◆ FactorIndex

typedef std::uint64_t gtsam::FactorIndex

Integer nonlinear factor index type.

Definition at line 100 of file types.h.

◆ FactorIndexSet

typedef FastSet<FactorIndex> gtsam::FactorIndexSet

Definition at line 38 of file Factor.h.

◆ FactorIndices

typedef FastVector<FactorIndex> gtsam::FactorIndices

Define collection types:

Define collection type:

Definition at line 37 of file Factor.h.

◆ FixedLagSmootherKeyTimestampMap

typedef FixedLagSmoother::KeyTimestampMap gtsam::FixedLagSmootherKeyTimestampMap

Typedef for matlab wrapping.

Definition at line 134 of file nonlinear/FixedLagSmoother.h.

◆ FixedLagSmootherKeyTimestampMapValue

typedef FixedLagSmootherKeyTimestampMap::value_type gtsam::FixedLagSmootherKeyTimestampMapValue

Definition at line 135 of file nonlinear/FixedLagSmoother.h.

◆ FixedLagSmootherResult

typedef FixedLagSmoother::Result gtsam::FixedLagSmootherResult

Definition at line 136 of file nonlinear/FixedLagSmoother.h.

◆ GaussianFactorGraphValuePair

using gtsam::GaussianFactorGraphValuePair = typedef std::pair<GaussianFactorGraph, double>

Definition at line 31 of file HybridGaussianProductFactor.h.

◆ GaussianFactorValuePair

using gtsam::GaussianFactorValuePair = typedef std::pair<GaussianFactor::shared_ptr, double>

Alias for pair of GaussianFactor::shared_pointer and a double value.

Definition at line 38 of file HybridGaussianFactor.h.

◆ GraphAndValues

using gtsam::GraphAndValues = typedef std::pair<NonlinearFactorGraph::shared_ptr, Values::shared_ptr>

Return type for load functions, which return a graph and initial values. For landmarks, the gtsam::Symbol L(index) is used to insert into the Values. Bearing-range measurements also refer to landmarks with L(index).

Definition at line 143 of file dataset.h.

◆ index_sequence_for

template<class... T>

using gtsam::index_sequence_for = typedef make_index_sequence<sizeof...(T)>

Definition at line 58 of file base/utilities.h.

◆ IndexedEdge

typedef std::pair<std::pair<size_t, size_t>, Pose2> gtsam::IndexedEdge

Definition at line 113 of file dataset.h.

◆ IndexedLandmark

typedef std::pair<size_t, Point2> gtsam::IndexedLandmark

Definition at line 112 of file dataset.h.

◆ IndexedPose

typedef std::pair<size_t, Pose2> gtsam::IndexedPose

Return type for auxiliary functions.

Definition at line 111 of file dataset.h.

◆ IndexPairSet

typedef std::set<IndexPair> gtsam::IndexPairSet

Definition at line 126 of file DSFMap.h.

◆ IndexPairSetMap

gtsam::IndexPairSetMap = dict

Definition at line 130 of file DSFMap.h.

◆ IndexPairVector

gtsam::IndexPairVector = list

Definition at line 125 of file DSFMap.h.

◆ ISAM2ThresholdMapValue

typedef ISAM2ThresholdMap::value_type gtsam::ISAM2ThresholdMapValue

Definition at line 135 of file ISAM2Params.h.

◆ JacobianVector

using gtsam::JacobianVector = typedef std::vector<Matrix>

Definition at line 24 of file CustomFactor.h.

◆ Key

typedef std::uint64_t gtsam::Key

Integer nonlinear key type.

Definition at line 97 of file types.h.

◆ KeyDimMap

using gtsam::KeyDimMap = typedef std::map<Key, uint32_t>

Mapping between variable's key and its corresponding dimensionality.

Definition at line 32 of file LP.h.

◆ KeyFormatter

using gtsam::KeyFormatter = typedef std::function<std::string(Key)>

Typedef for a function to format a key, i.e. to convert it to a string.

Definition at line 35 of file Key.h.

◆ KeyGroupMap

using gtsam::KeyGroupMap = typedef FastMap<Key, int>

Definition at line 97 of file Key.h.

◆ KeyList

using gtsam::KeyList = typedef FastList<Key>

Definition at line 95 of file Key.h.

◆ KeyPairDoubleMap

gtsam::KeyPairDoubleMap = dict

Definition at line 99 of file MFAS.h.

◆ KeyRotMap

typedef std::map<Key, Rot3> gtsam::KeyRotMap

Definition at line 34 of file InitializePose3.h.

◆ KeySet

using gtsam::KeySet = typedef FastSet<Key>

Definition at line 96 of file Key.h.

◆ KeyVector

gtsam::KeyVector = list

Define collection type once and for all - also used in wrappers.

Typedefs to allow for backwards compatibility TODO(Varun) deprecate in future release gtsam.

Definition at line 92 of file Key.h.

◆ KeyVectorMap

typedef std::map<Key, std::vector<size_t> > gtsam::KeyVectorMap

Definition at line 33 of file InitializePose3.h.

◆ Line3_

typedef Expression<Line3> gtsam::Line3_

Definition at line 40 of file slam/expressions.h.

◆ LPSolver

using gtsam::LPSolver = typedef ActiveSetSolver<LP, LPPolicy, LPInitSolver>

Definition at line 79 of file LPSolver.h.

◆ Matrix

typedef Eigen::MatrixXd gtsam::Matrix

Definition at line 39 of file base/Matrix.h.

◆ MatrixRowMajor

typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> gtsam::MatrixRowMajor

Definition at line 40 of file base/Matrix.h.

◆ MotionModel

using gtsam::MotionModel = typedef BetweenFactor<double>

Definition at line 120 of file Switching.h.

◆ NavState_

typedef Expression<NavState> gtsam::NavState_

Definition at line 17 of file navigation/expressions.h.

◆ NonlinearFactorValuePair

using gtsam::NonlinearFactorValuePair = typedef std::pair<NoiseModelFactor::shared_ptr, double>

Alias for a NoiseModelFactor shared pointer and double scalar pair.

Definition at line 35 of file HybridNonlinearFactor.h.

◆ OptionalMatrixType

using gtsam::OptionalMatrixType = typedef Matrix*

This typedef will be used everywhere boost::optional<Matrix&> reference was used previously. This is used to indicate that the Jacobian is optional. In the future we will change this to OptionalJacobian

Definition at line 55 of file NonlinearFactor.h.

◆ OptionalMatrixVecType

using gtsam::OptionalMatrixVecType = typedef std::vector<Matrix>*

The OptionalMatrixVecType is a pointer to a vector of matrices. It will be used in situations where a vector of matrices is optional, like in unwhitenedError.

Definition at line 61 of file NonlinearFactor.h.

◆ OrientedPlane3_

typedef Expression<OrientedPlane3> gtsam::OrientedPlane3_

Definition at line 41 of file slam/expressions.h.

◆ OrphanWrapper

using gtsam::OrphanWrapper = typedef BayesTreeOrphanWrapper<HybridBayesTree::Clique>

Definition at line 58 of file HybridGaussianFactorGraph.cpp.

◆ Pairs

using gtsam::Pairs = typedef std::vector<std::pair<Key, Matrix> >

Definition at line 44 of file JacobianFactor.cpp.

◆ Parser

template<typename T >

using gtsam::Parser = typedef std::function<std::optional<T>(std::istream &is, const std::string &tag)>

Definition at line 124 of file dataset.cpp.

◆ PinholeCameraCal3_S2

using gtsam::PinholeCameraCal3_S2 = typedef gtsam::PinholeCamera<gtsam::Cal3_S2>

Convenient aliases for Pinhole camera classes with different calibrations. Also needed as forward declarations in the wrapper.

Definition at line 34 of file SimpleCamera.h.

◆ PinholeCameraCal3Bundler

using gtsam::PinholeCameraCal3Bundler = typedef gtsam::PinholeCamera<gtsam::Cal3Bundler>

Definition at line 35 of file SimpleCamera.h.

◆ PinholeCameraCal3DS2

using gtsam::PinholeCameraCal3DS2 = typedef gtsam::PinholeCamera<gtsam::Cal3DS2>

Definition at line 36 of file SimpleCamera.h.

◆ PinholeCameraCal3Fisheye

using gtsam::PinholeCameraCal3Fisheye = typedef gtsam::PinholeCamera<gtsam::Cal3Fisheye>

Definition at line 38 of file SimpleCamera.h.

◆ PinholeCameraCal3Unified

using gtsam::PinholeCameraCal3Unified = typedef gtsam::PinholeCamera<gtsam::Cal3Unified>

Definition at line 37 of file SimpleCamera.h.

◆ Point2

typedef Vector2 gtsam::Point2

As of GTSAM 4, in order to make GTSAM more lean, it is now possible to just typedef Point2 to Vector2

Definition at line 32 of file Point2.h.

◆ Point2_

typedef Expression<Point2> gtsam::Point2_

Definition at line 22 of file slam/expressions.h.

◆ Point2Pair

using gtsam::Point2Pair = typedef std::pair<Point2, Point2>

Definition at line 35 of file Point2.h.

◆ Point2Pairs

gtsam::Point2Pairs = list

Definition at line 38 of file Point2.h.

◆ Point2Vector

gtsam::Point2Vector = list

Definition at line 49 of file Point2.h.

◆ Point3

typedef Vector3 gtsam::Point3

As of GTSAM 4, in order to make GTSAM more lean, it is now possible to just typedef Point3 to Vector3

Definition at line 38 of file Point3.h.

◆ Point3_

typedef Expression<Point3> gtsam::Point3_

Definition at line 36 of file slam/expressions.h.

◆ Point3Pair

using gtsam::Point3Pair = typedef std::pair<Point3, Point3>

Definition at line 42 of file Point3.h.

◆ Point3Pairs

gtsam::Point3Pairs = list

Definition at line 45 of file Point3.h.

◆ Point3Vector

typedef std::vector<Point3, Eigen::aligned_allocator<Point3> > gtsam::Point3Vector

Definition at line 39 of file Point3.h.

◆ Pose2_

typedef Expression<Pose2> gtsam::Pose2_

Definition at line 24 of file slam/expressions.h.

◆ Pose2Pair

using gtsam::Pose2Pair = typedef std::pair<Pose2, Pose2>

Definition at line 361 of file Pose2.h.

◆ Pose2Pairs

gtsam::Pose2Pairs = list

Definition at line 362 of file Pose2.h.

◆ Pose3_

typedef Expression<Pose3> gtsam::Pose3_

Definition at line 39 of file slam/expressions.h.

◆ Pose3Pair

using gtsam::Pose3Pair = typedef std::pair<Pose3, Pose3>

Definition at line 424 of file Pose3.h.

◆ Pose3Pairs

gtsam::Pose3Pairs = list

Definition at line 425 of file Pose3.h.

◆ Pose3Vector

gtsam::Pose3Vector = list

Definition at line 428 of file Pose3.h.

◆ PreintegrationType

typedef ManifoldPreintegration gtsam::PreintegrationType

Definition at line 33 of file CombinedImuFactor.h.

◆ QPSolver

using gtsam::QPSolver = typedef ActiveSetSolver<QP, QPPolicy, QPInitSolver>

Definition at line 48 of file QPSolver.h.

◆ Quaternion

typedef Eigen::Quaternion<double, Eigen::DontAlign> gtsam::Quaternion

Definition at line 182 of file geometry/Quaternion.h.

◆ ResultTree

using gtsam::ResultTree = typedef DecisionTree<Key, Result>

Definition at line 73 of file HybridGaussianFactorGraph.cpp.

◆ Rot2_

typedef Expression<Rot2> gtsam::Rot2_

Definition at line 23 of file slam/expressions.h.

◆ Rot3_

typedef Expression<Rot3> gtsam::Rot3_

Definition at line 38 of file slam/expressions.h.

◆ Rot3Vector

gtsam::Rot3Vector = list

std::vector of Rot3s, used in Matlab wrapper

Definition at line 564 of file Rot3.h.

◆ Row

using gtsam::Row = typedef std::vector<double>

Definition at line 9 of file SignatureParser.cpp.

◆ RowVector

typedef Eigen::RowVectorXd gtsam::RowVector

Definition at line 25 of file LinearCost.h.

◆ Sample

using gtsam::Sample = typedef std::pair<double, double>

A sample is a key-value pair from a sequence.

Definition at line 38 of file FitBasis.h.

◆ Sequence

using gtsam::Sequence = typedef std::map<double, double>

Our sequence representation is a map of {x: y} values where y = f(x)

Definition at line 36 of file FitBasis.h.

◆ SfmCamera

typedef PinholeCamera<Cal3Bundler> gtsam::SfmCamera

Define the structure for the camera poses.

Definition at line 33 of file SfmData.h.

◆ SfmMeasurement

typedef std::pair<size_t, Point2> gtsam::SfmMeasurement

A measurement with its camera index.

Definition at line 32 of file SfmTrack.h.

◆ SfmTrack2dVector

gtsam::SfmTrack2dVector = list

Definition at line 119 of file SfmTrack.h.

◆ SharedConstrained

typedef noiseModel::Constrained::shared_ptr gtsam::SharedConstrained

Definition at line 765 of file NoiseModel.h.

◆ SharedDiagonal

typedef noiseModel::Diagonal::shared_ptr gtsam::SharedDiagonal

Definition at line 764 of file NoiseModel.h.

◆ SharedFactor

using gtsam::SharedFactor = typedef std::shared_ptr<Factor>

Definition at line 32 of file HybridFactorGraph.h.

◆ SharedGaussian

typedef noiseModel::Gaussian::shared_ptr gtsam::SharedGaussian

Definition at line 763 of file NoiseModel.h.

◆ SharedIsotropic

typedef noiseModel::Isotropic::shared_ptr gtsam::SharedIsotropic

Definition at line 766 of file NoiseModel.h.

◆ SharedNoiseModel

typedef noiseModel::Base::shared_ptr gtsam::SharedNoiseModel

Aliases. Deliberately not in noiseModel namespace.

Definition at line 762 of file NoiseModel.h.

◆ ShonanAveragingParameters2

using gtsam::ShonanAveragingParameters2 = typedef ShonanAveragingParameters<2>

Definition at line 104 of file ShonanAveraging.h.

◆ ShonanAveragingParameters3

using gtsam::ShonanAveragingParameters3 = typedef ShonanAveragingParameters<3>

Definition at line 105 of file ShonanAveraging.h.

◆ ShonanFactor2

using gtsam::ShonanFactor2 = typedef ShonanFactor<2>

Definition at line 89 of file ShonanFactor.h.

◆ ShonanFactor3

using gtsam::ShonanFactor3 = typedef ShonanFactor<3>

Definition at line 90 of file ShonanFactor.h.

◆ SiftIndex

typedef std::pair<size_t, size_t> gtsam::SiftIndex

Sift index for SfmTrack.

Definition at line 35 of file SfmTrack.h.

◆ SimPolygon2DVector

typedef std::vector<SimPolygon2D> gtsam::SimPolygon2DVector

Definition at line 131 of file SimPolygon2D.h.

◆ SimWall2DVector

typedef std::vector<SimWall2D> gtsam::SimWall2DVector

Definition at line 77 of file SimWall2D.h.

◆ SmartStereoProjectionParams

typedef SmartProjectionParams gtsam::SmartStereoProjectionParams

Definition at line 45 of file SmartStereoProjectionFactor.h.

◆ SO3

using gtsam::SO3 = typedef SO<3>

Definition at line 34 of file SO3.h.

◆ SO4

using gtsam::SO4 = typedef SO<4>

Definition at line 34 of file SO4.h.

◆ SOn

using gtsam::SOn = typedef SO<Eigen::Dynamic>

Definition at line 342 of file SOn.h.

◆ Sparse

typedef Eigen::SparseMatrix< double > gtsam::Sparse

Definition at line 26 of file AcceleratedPowerMethod.h.

◆ SparseEigen

typedef Eigen::SparseMatrix<double, Eigen::ColMajor, int> gtsam::SparseEigen

Eigen-format sparse matrix. Note: ColMajor is ~20% faster since InnerIndices must be sorted

Definition at line 35 of file SparseEigen.h.

◆ SparseTriplets

using gtsam::SparseTriplets = typedef std::vector<std::tuple<int, int, double> >

Definition at line 118 of file GaussianFactorGraph.cpp.

◆ State

typedef internal::NonlinearOptimizerState gtsam::State

Definition at line 62 of file DoglegOptimizer.cpp.

◆ StereoPoint2Vector

typedef std::vector<StereoPoint2> gtsam::StereoPoint2Vector

Definition at line 168 of file StereoPoint2.h.

◆ SubMatrix

typedef Eigen::Block<Matrix> gtsam::SubMatrix

Definition at line 69 of file base/Matrix.h.

◆ SubVector

typedef Eigen::VectorBlock<Vector> gtsam::SubVector

Definition at line 65 of file Vector.h.

◆ SuccessiveLinearizationParams

typedef NonlinearOptimizerParams gtsam::SuccessiveLinearizationParams

Definition at line 185 of file NonlinearOptimizerParams.h.

◆ SymbolicCluster

using gtsam::SymbolicCluster = typedef SymbolicJunctionTree::Cluster

typedef for wrapper:

Definition at line 69 of file SymbolicJunctionTree.h.

◆ Table

using gtsam::Table = typedef std::vector<Row>

Definition at line 10 of file SignatureParser.cpp.

◆ Unit3_

typedef Expression<Unit3> gtsam::Unit3_

Definition at line 37 of file slam/expressions.h.

◆ Vector

typedef Eigen::VectorXd gtsam::Vector

Definition at line 38 of file Vector.h.

◆ Vector1

typedef Eigen::Matrix<double, 1, 1> gtsam::Vector1

Definition at line 41 of file Vector.h.

◆ Vector1_

typedef Expression<Vector1> gtsam::Vector1_

Definition at line 29 of file nonlinear/expressions.h.

◆ Vector2

typedef Eigen::Vector2d gtsam::Vector2

Definition at line 42 of file Vector.h.

◆ Vector2_

typedef Expression<Vector2> gtsam::Vector2_

Definition at line 30 of file nonlinear/expressions.h.

◆ Vector3

typedef Eigen::Vector3d gtsam::Vector3

Definition at line 43 of file Vector.h.

◆ Vector3_

typedef Expression<Vector3> gtsam::Vector3_

Definition at line 31 of file nonlinear/expressions.h.

◆ Vector4_

typedef Expression<Vector4> gtsam::Vector4_

Definition at line 32 of file nonlinear/expressions.h.

◆ Vector5_

typedef Expression<Vector5> gtsam::Vector5_

Definition at line 33 of file nonlinear/expressions.h.

◆ Vector6_

typedef Expression<Vector6> gtsam::Vector6_

Definition at line 34 of file nonlinear/expressions.h.

◆ Vector7_

typedef Expression<Vector7> gtsam::Vector7_

Definition at line 35 of file nonlinear/expressions.h.

◆ Vector8_

typedef Expression<Vector8> gtsam::Vector8_

Definition at line 36 of file nonlinear/expressions.h.

◆ Vector9_

typedef Expression<Vector9> gtsam::Vector9_

Definition at line 37 of file nonlinear/expressions.h.

◆ Velocity3

typedef Vector3 gtsam::Velocity3

Velocity is currently typedef'd to Vector3.

Syntactic sugar to clarify components.

Definition at line 28 of file NavState.h.

◆ Velocity3_

typedef Expression<Velocity3> gtsam::Velocity3_

Definition at line 18 of file navigation/expressions.h.

◆ void_t

template<typename ... >

using gtsam::void_t = typedef void

Convenience void_t as we assume C++11, it will not conflict the std one in C++17 as this is in gtsam::

Definition at line 248 of file types.h.

◆ Weights

using gtsam::Weights = typedef Eigen::Matrix<double, 1, -1>

Definition at line 69 of file Basis.h.

◆ Y

using gtsam::Y = typedef GaussianFactorGraphValuePair

Definition at line 29 of file HybridGaussianProductFactor.cpp.

Enumeration Type Documentation

◆ DegeneracyMode

enum gtsam::DegeneracyMode

How to manage degeneracy.

Enumerator
IGNORE_DEGENERACY
ZERO_ON_DEGENERACY
HANDLE_INFINITY

Definition at line 35 of file SmartFactorParams.h.

◆ DirectionMethod

enum gtsam::DirectionMethod

strong

Enumerator
FletcherReeves
PolakRibiere
HestenesStiefel
DaiYuan

Definition at line 72 of file NonlinearConjugateGradientOptimizer.h.

◆ GncLossType

enum gtsam::GncLossType

Choice of robust loss function for GNC.

Enumerator
GM
TLS

Definition at line 36 of file GncParams.h.

◆ KernelFunctionType

enum gtsam::KernelFunctionType

Robust kernel type to wrap around quadratic noise model.

Enumerator
KernelFunctionTypeNONE
KernelFunctionTypeHUBER
KernelFunctionTypeTUKEY

Definition at line 74 of file dataset.h.

◆ LinearizationMode

enum gtsam::LinearizationMode

Linearization mode: what factor to linearize to.

SmartFactorParams: parameters and (linearization/degeneracy) modes for SmartProjection and SmartStereoProjection factors

Enumerator
HESSIAN
IMPLICIT_SCHUR
JACOBIAN_Q
JACOBIAN_SVD

Definition at line 30 of file SmartFactorParams.h.

◆ NoiseFormat

enum gtsam::NoiseFormat

Indicates how noise parameters are stored in file.

Enumerator
NoiseFormatG2O	Information matrix I11, I12, I13, I22, I23, I33.
NoiseFormatTORO	Information matrix, but inf_ff inf_fs inf_ss inf_rr inf_fr inf_sr.
NoiseFormatGRAPH	default: toro-style order, but covariance matrix !
NoiseFormatCOV	Covariance matrix C11, C12, C13, C22, C23, C33.
NoiseFormatAUTO	Try to guess covariance matrix layout.

Definition at line 65 of file dataset.h.

Function Documentation

◆ _defaultKeyFormatter()

GTSAM_EXPORT std::string gtsam::_defaultKeyFormatter ( Key key )

Definition at line 33 of file Key.cpp.

◆ _init()

def gtsam._init ( )

private

This function is to add shims for the long-gone Point2 and Point3 types

Definition at line 52 of file python/gtsam/__init__.py.

◆ _multirobotKeyFormatter()

GTSAM_EXPORT std::string gtsam::_multirobotKeyFormatter ( Key key )

Definition at line 49 of file Key.cpp.

◆ _truePredicate()

template<typename T >

static bool gtsam::_truePredicate ( const T & )

static

Definition at line 46 of file Values.h.

◆ add()

static Y gtsam::add	(	const Y &	y1,
		const Y &	y2
	)

static

Definition at line 32 of file HybridGaussianProductFactor.cpp.

◆ allocAligned()

std::unique_ptr<internal::ExecutionTraceStorage[]> gtsam::allocAligned ( size_t size )

inline

Definition at line 197 of file Expression-inl.h.

◆ apply() [1/3]

template<typename L , typename Y >

DecisionTree<L, Y> gtsam::apply	(	const DecisionTree< L, Y > &	f,
		const DecisionTree< L, Y > &	g,
		const typename DecisionTree< L, Y >::Binary &	op
	)

Apply binary operator op to DecisionTree f.

Definition at line 474 of file DecisionTree.h.

◆ apply() [2/3]

template<typename L , typename Y >

DecisionTree<L, Y> gtsam::apply	(	const DecisionTree< L, Y > &	f,
		const typename DecisionTree< L, Y >::Unary &	op
	)

Apply unary operator op to DecisionTree f.

free versions of apply

Definition at line 460 of file DecisionTree.h.

◆ apply() [3/3]

template<typename L , typename Y >

DecisionTree<L, Y> gtsam::apply	(	const DecisionTree< L, Y > &	f,
		const typename DecisionTree< L, Y >::UnaryAssignment &	op
	)

Apply unary operator op with Assignment to DecisionTree f.

Definition at line 467 of file DecisionTree.h.

◆ assert_container_equal() [1/4]

template<class V2 >

bool gtsam::assert_container_equal	(	const std::map< size_t, V2 > &	expected,
		const std::map< size_t, V2 > &	actual,
		double	tol = `1e-9`
	)

Function for comparing maps of size_t->testable

Definition at line 128 of file TestableAssertions.h.

◆ assert_container_equal() [2/4]

template<class V1 , class V2 >

bool gtsam::assert_container_equal	(	const std::map< V1, V2 > &	expected,
		const std::map< V1, V2 > &	actual,
		double	tol = `1e-9`
	)

Function for comparing maps of testable->testable TODO: replace with more generalized version

Definition at line 90 of file TestableAssertions.h.

◆ assert_container_equal() [3/4]

template<class V1 , class V2 >

bool gtsam::assert_container_equal	(	const std::vector< std::pair< V1, V2 > > &	expected,
		const std::vector< std::pair< V1, V2 > > &	actual,
		double	tol = `1e-9`
	)

Function for comparing vector of pairs (testable, testable)

Definition at line 166 of file TestableAssertions.h.

◆ assert_container_equal() [4/4]

template<class V >

bool gtsam::assert_container_equal	(	const V &	expected,
		const V &	actual,
		double	tol = `1e-9`
	)

General function for comparing containers of testable objects

Definition at line 206 of file TestableAssertions.h.

◆ assert_container_equality() [1/2]

template<class V2 >

bool gtsam::assert_container_equality	(	const std::map< size_t, V2 > &	expected,
		const std::map< size_t, V2 > &	actual
	)

Function for comparing maps of size_t->testable Types are assumed to have operator ==

Definition at line 237 of file TestableAssertions.h.

◆ assert_container_equality() [2/2]

template<class V >

bool gtsam::assert_container_equality	(	const V &	expected,
		const V &	actual
	)

General function for comparing containers of objects with operator==

Definition at line 275 of file TestableAssertions.h.

◆ assert_equal() [1/11]

GTSAM_EXPORT bool gtsam::assert_equal	(	const ConstSubVector &	expected,
		const ConstSubVector &	actual,
		double	tol
	)

Definition at line 171 of file Vector.cpp.

◆ assert_equal() [2/11]

bool gtsam::assert_equal	(	const Key &	expected,
		const Key &	actual,
		double	tol = `0.0`
	)

inline

Equals testing for basic types

Definition at line 35 of file TestableAssertions.h.

◆ assert_equal() [3/11]

bool gtsam::assert_equal	(	const Matrix &	A,
		const Matrix &	B,
		double	tol = `1e-9`
	)

equals with an tolerance, prints out message if unequal

Definition at line 40 of file Matrix.cpp.

◆ assert_equal() [4/11]

bool gtsam::assert_equal	(	const std::list< Matrix > &	As,
		const std::list< Matrix > &	Bs,
		double	tol = `1e-9`
	)

equals with an tolerance, prints out message if unequal

Definition at line 69 of file Matrix.cpp.

◆ assert_equal() [5/11]

template<class V >

bool gtsam::assert_equal	(	const std::optional< V > &	expected,
		const std::optional< V > &	actual,
		double	tol = `1e-9`
	)

Comparisons for std.optional objects that checks whether objects exist before comparing their values. First version allows for both to be std::nullopt, but the second, with expected given rather than optional

Concept requirement: V is testable

Definition at line 51 of file TestableAssertions.h.

◆ assert_equal() [6/11]

bool gtsam::assert_equal	(	const std::string &	expected,
		const std::string &	actual
	)

inline

Compare strings for unit tests

Definition at line 304 of file TestableAssertions.h.

◆ assert_equal() [7/11]

bool gtsam::assert_equal	(	const SubVector &	vec1,
		const SubVector &	vec2,
		double	tol = `1e-9`
	)

Same, prints if error

Parameters

vec1	Vector
vec2	Vector
tol	1e-9

Returns: bool

Definition at line 162 of file Vector.cpp.

◆ assert_equal() [8/11]

template<class V >

bool gtsam::assert_equal	(	const V &	expected,
		const std::optional< std::reference_wrapper< const V >> &	actual,
		double	tol = `1e-9`
	)

Definition at line 76 of file TestableAssertions.h.

◆ assert_equal() [9/11]

template<class V >

bool gtsam::assert_equal	(	const V &	expected,
		const std::optional< V > &	actual,
		double	tol = `1e-9`
	)

Definition at line 67 of file TestableAssertions.h.

◆ assert_equal() [10/11]

template<class V >

bool gtsam::assert_equal	(	const V &	expected,
		const V &	actual,
		double	tol = `1e-9`
	)

This template works for any type with equals

Definition at line 99 of file Testable.h.

◆ assert_equal() [11/11]

bool gtsam::assert_equal	(	const Vector &	vec1,
		const Vector &	vec2,
		double	tol = `1e-9`
	)

Same, prints if error

Parameters

vec1	Vector
vec2	Vector
tol	1e-9

Returns: bool

Definition at line 144 of file Vector.cpp.

◆ assert_inequal() [1/3]

bool gtsam::assert_inequal	(	const Matrix &	A,
		const Matrix &	B,
		double	tol = `1e-9`
	)

inequals with an tolerance, prints out message if within tolerance

Definition at line 60 of file Matrix.cpp.

◆ assert_inequal() [2/3]

template<class V >

bool gtsam::assert_inequal	(	const V &	expected,
		const V &	actual,
		double	tol = `1e-9`
	)

Allow for testing inequality

Definition at line 317 of file TestableAssertions.h.

◆ assert_inequal() [3/3]

bool gtsam::assert_inequal	(	const Vector &	vec1,
		const Vector &	vec2,
		double	tol = `1e-9`
	)

Not the same, prints if error

Parameters

vec1	Vector
vec2	Vector
tol	1e-9

Returns: bool

Definition at line 153 of file Vector.cpp.

◆ assert_print_equal()

template<class V >

bool gtsam::assert_print_equal	(	const std::string &	expected,
		const V &	actual,
		const std::string &	s = `""`
	)

Capture print function output and compare against string.

Parameters

s	Optional string to pass to the print() method.

Definition at line 352 of file TestableAssertions.h.

◆ assert_stdout_equal()

template<class V >

bool gtsam::assert_stdout_equal	(	const std::string &	expected,
		const V &	actual
	)

Capture std out via cout stream and compare against string.

Definition at line 330 of file TestableAssertions.h.

◆ attitude()

Rot3_ gtsam::attitude ( const NavState_ & X )

inline

Definition at line 34 of file navigation/expressions.h.

◆ axpy()

void gtsam::axpy	(	double	alpha,
		const Errors &	x,
		Errors &	y
	)

BLAS level 2 style AXPY, y := alpha*x + y

Definition at line 110 of file Errors.cpp.

◆ backSubstituteLower()

Vector gtsam::backSubstituteLower	(	const Matrix &	L,
		const Vector &	b,
		bool	unit = `false`
	)

backSubstitute L*x=b

Parameters

L	an lower triangular matrix
b	an RHS vector
unit,set	true if unit triangular

Returns: the solution x of L*x=b

Definition at line 365 of file Matrix.cpp.

◆ backSubstituteUpper() [1/2]

Vector gtsam::backSubstituteUpper	(	const Matrix &	U,
		const Vector &	b,
		bool	unit = `false`
	)

backSubstitute U*x=b

Parameters

U	an upper triangular matrix
b	an RHS vector
unit,set	true if unit triangular

Returns: the solution x of U*x=b

Definition at line 375 of file Matrix.cpp.

◆ backSubstituteUpper() [2/2]

Vector gtsam::backSubstituteUpper	(	const Vector &	b,
		const Matrix &	U,
		bool	unit = `false`
	)

backSubstitute x'*U=b'

Parameters

U	an upper triangular matrix
b	an RHS vector
unit,set	true if unit triangular

Returns: the solution x of x'*U=b'

Definition at line 385 of file Matrix.cpp.

◆ BCH()

template<class T >

T gtsam::BCH	(	const T &	X,
		const T &	Y
	)

AGC: bracket() only appears in Rot3 tests, should this be used elsewhere?

Three term approximation of the Baker-Campbell-Hausdorff formula In non-commutative Lie groups, when composing exp(Z) = exp(X)exp(Y) it is not true that Z = X+Y. Instead, Z can be calculated using the BCH formula: Z = X + Y + [X,Y]/2 + [X-Y,[X,Y]]/12 - [Y,[X,[X,Y]]]/24 http://en.wikipedia.org/wiki/Baker-Campbell-Hausdorff_formula

Definition at line 298 of file Lie.h.

◆ between()

template<typename T >

Expression<T> gtsam::between	(	const Expression< T > &	t1,
		const Expression< T > &	t2
	)

Definition at line 17 of file nonlinear/expressions.h.

◆ between_default()

template<class Class >

Class gtsam::between_default	(	const Class &	l1,
		const Class &	l2
	)

inline

These core global functions can be specialized by new Lie types for better performance. Compute l0 s.t. l2=l1*l0

Definition at line 240 of file Lie.h.

◆ bound()

double gtsam::bound	(	double	a,
		double	min,
		double	max
	)

Definition at line 17 of file PoseRTV.cpp.

◆ buildFactorSubgraph()

GaussianFactorGraph gtsam::buildFactorSubgraph	(	const GaussianFactorGraph &	gfg,
		const Subgraph &	subgraph,
		const bool	clone
	)

Select the factors in a factor graph according to the subgraph.

Definition at line 407 of file SubgraphBuilder.cpp.

◆ buildVectorValues() [1/3]

VectorValues gtsam::buildVectorValues	(	const Vector &	v,
		const KeyInfo &	keyInfo
	)

Create VectorValues from a Vector and a KeyInfo class.

Definition at line 166 of file PCGSolver.cpp.

◆ buildVectorValues() [2/3]

VectorValues gtsam::buildVectorValues	(	const Vector &	v,
		const Ordering &	ordering,
		const map< Key, size_t > &	dimensions
	)

Create VectorValues from a Vector.

Definition at line 145 of file PCGSolver.cpp.

◆ buildVectorValues() [3/3]

VectorValues gtsam::buildVectorValues	(	const Vector &	v,
		const Ordering &	ordering,
		const std::map< Key, size_t > &	dimensions
	)

Create VectorValues from a Vector.

Definition at line 145 of file PCGSolver.cpp.

◆ CalculateBestAxis()

static Point3 gtsam::CalculateBestAxis ( const Point3 & n )

static

Definition at line 72 of file Unit3.cpp.

◆ calibrateJacobians()

template<typename Cal , size_t Dim>

void gtsam::calibrateJacobians	(	const Cal &	calibration,
		const Point2 &	pn,
		OptionalJacobian< 2, Dim >	Dcal = `{}`,
		OptionalJacobian< 2, 2 >	Dp = `{}`
	)

Function which makes use of the Implicit Function Theorem to compute the Jacobians of calibrate using uncalibrate. This is useful when there are iterative operations in the calibrate function which make computing jacobians difficult.

Given f(pi, pn) = uncalibrate(pn) - pi, and g(pi) = calibrate, we can easily compute the Jacobians: df/pi = -I (pn and pi are independent args) Dp = -inv(H_uncal_pn) * df/pi = -inv(H_uncal_pn) * (-I) = inv(H_uncal_pn) Dcal = -inv(H_uncal_pn) * df/K = -inv(H_uncal_pn) * H_uncal_K

Template Parameters

Cal	Calibration model.
Dim	The number of parameters in the calibration model.

Parameters

p	Calibrated point.
Dcal	optional 2*p Jacobian wrpt `p` Cal3DS2 parameters.
Dp	optional 2*2 Jacobian wrpt intrinsic coordinates.

Definition at line 47 of file Cal3.h.

◆ calibrateMeasurements() [1/2]

template<class CAMERA >

Point3Vector gtsam::calibrateMeasurements	(	const CameraSet< CAMERA > &	cameras,
		const typename CAMERA::MeasurementVector &	measurements
	)

inline

Convert pixel measurements in image to homogeneous measurements in the image plane using camera intrinsics of each measurement.

Template Parameters

CAMERA Camera type to use.

Parameters

cameras	Cameras corresponding to each measurement.
measurements	Vector of measurements to undistort.

Returns: homogeneous measurements in image plane

Definition at line 381 of file triangulation.h.

◆ calibrateMeasurements() [2/2]

template<class CAMERA = SphericalCamera>

Point3Vector gtsam::calibrateMeasurements	(	const CameraSet< SphericalCamera > &	cameras,
		const SphericalCamera::MeasurementVector &	measurements
	)

inline

Specialize for SphericalCamera to do nothing.

Definition at line 397 of file triangulation.h.

◆ calibrateMeasurementsShared()

template<class CALIBRATION >

Point3Vector gtsam::calibrateMeasurementsShared	(	const CALIBRATION &	cal,
		const Point2Vector &	measurements
	)

inline

Convert pixel measurements in image to homogeneous measurements in the image plane using shared camera intrinsics.

Template Parameters

CALIBRATION Calibration type to use.

Parameters

cal	Calibration with which measurements were taken.
measurements	Vector of measurements to undistort.

Returns: homogeneous measurements in image plane

Definition at line 357 of file triangulation.h.

◆ cartesianProduct()

std::vector<DiscreteValues> gtsam::cartesianProduct ( const DiscreteKeys & keys )

inline

Free version of CartesianProduct.

Definition at line 124 of file DiscreteValues.h.

◆ check()

static void gtsam::check	(	const SharedNoiseModel &	noiseModel,
		size_t	m
	)

static

Definition at line 97 of file NonlinearFactor.cpp.

◆ check_sharedCliques()

template<class CLIQUE >

bool gtsam::check_sharedCliques	(	const std::pair< Key, typename BayesTree< CLIQUE >::sharedClique > &	v1,
		const std::pair< Key, typename BayesTree< CLIQUE >::sharedClique > &	v2
	)

Definition at line 259 of file BayesTree-inst.h.

◆ checkConditional()

GaussianConditional::shared_ptr gtsam::checkConditional ( const GaussianFactor::shared_ptr & factor )

Definition at line 38 of file HybridGaussianConditional.cpp.

◆ checkConvergence() [1/2]

GTSAM_EXPORT bool gtsam::checkConvergence	(	const NonlinearOptimizerParams &	params,
		double	currentError,
		double	newError
	)

Definition at line 234 of file NonlinearOptimizer.cpp.

◆ checkConvergence() [2/2]

bool gtsam::checkConvergence	(	double	relativeErrorTreshold,
		double	absoluteErrorTreshold,
		double	errorThreshold,
		double	currentError,
		double	newError,
		NonlinearOptimizerParams::Verbosity	verbosity = `NonlinearOptimizerParams::SILENT`
	)

Check whether the relative error decrease is less than relativeErrorTreshold, the absolute error decrease is less than absoluteErrorTreshold, or the error itself is less than errorThreshold.

Definition at line 182 of file NonlinearOptimizer.cpp.

◆ Chi2inv()

static double gtsam::Chi2inv	(	const double	alpha,
		const size_t	dofs
	)

static

Definition at line 38 of file GncOptimizer.h.

◆ cholesky_inverse()

Matrix gtsam::cholesky_inverse ( const Matrix & A )

Return the inverse of a S.P.D. matrix. Inversion is done via Cholesky decomposition.

Definition at line 537 of file Matrix.cpp.

◆ choleskyCareful()

pair<size_t, bool> gtsam::choleskyCareful	(	Matrix &	ATA,
		int	order = `-1`
	)

"Careful" Cholesky computes the positive square-root of a positive symmetric semi-definite matrix (i.e. that may be rank-deficient). Unlike standard Cholesky, the square-root factor may have all-zero rows for free variables.

Additionally, this function returns the index of the row after the last non-zero row in the computed factor, so that it may be truncated to an upper-trapazoidal matrix.

The second element of the return value is true if the matrix was factored successfully, or false if it was non-positive-semidefinite (i.e. indefinite or negative-(semi-)definite.

Note that this returned index is the rank of the matrix if and only if all of the zero-rows of the factor occur after any non-zero rows. This is (always?) the case during elimination of a fully-constrained least-squares problem.

The optional order argument specifies the size of the square upper-left submatrix to operate on, ignoring the rest of the matrix.

Definition at line 75 of file base/cholesky.cpp.

◆ choleskyPartial()

bool gtsam::choleskyPartial	(	Matrix &	ABC,
		size_t	nFrontal,
		size_t	topleft = `0`
	)

Partial Cholesky computes a factor [R S such that [R' 0 [R S = [A B 0 L] S' I] 0 L] B' C]. The input to this function is the matrix ABC = [A B], and the parameter [B' C] nFrontal determines the split between A, B, and C, with A being of size nFrontal x nFrontal.

if non-zero, factorization proceeds in bottom-right corner starting at topleft

Returns: true if the decomposition is successful, false if A was not positive-definite.

Definition at line 107 of file base/cholesky.cpp.

◆ choleskyStep()

static int gtsam::choleskyStep	(	Matrix &	ATA,
		size_t	k,
		size_t	order
	)

inlinestatic

Definition at line 35 of file base/cholesky.cpp.

◆ circleCircleIntersection() [1/3]

GTSAM_EXPORT std::optional< Point2 > gtsam::circleCircleIntersection	(	double	R_d,
		double	r_d,
		double	tol
	)

Definition at line 55 of file Point2.cpp.

◆ circleCircleIntersection() [2/3]

list<Point2> gtsam::circleCircleIntersection	(	Point2	c1,
		double	r1,
		Point2	c2,
		double	r2,
		double	tol = `1e-9`
	)

Intersect 2 circles.

Parameters

c1	center of first circle
r1	radius of first circle
c2	center of second circle
r2	radius of second circle
tol	absolute tolerance below which we consider touching circles

Returns: list of solutions (0,1, or 2). Identical circles will return empty list, as well.

Definition at line 99 of file Point2.cpp.

◆ circleCircleIntersection() [3/3]

GTSAM_EXPORT std::list< Point2 > gtsam::circleCircleIntersection	(	Point2	c1,
		Point2	c2,
		std::optional< Point2 >	fh
	)

Definition at line 70 of file Point2.cpp.

◆ collect() [1/2]

Matrix gtsam::collect	(	const std::vector< const Matrix * > &	matrices,
		size_t	m = `0`,
		size_t	n = `0`
	)

create a matrix by concatenating Given a set of matrices: A1, A2, A3... If all matrices have the same size, specifying single matrix dimensions will avoid the lookup of dimensions

Parameters

matrices	is a vector of matrices in the order to be collected
m	is the number of rows of a single matrix
n	is the number of columns of a single matrix

Returns: combined matrix [A1 A2 A3]

Definition at line 441 of file Matrix.cpp.

◆ collect() [2/2]

GTSAM_EXPORT Matrix gtsam::collect	(	size_t	nrMatrices,
			...
	)

Definition at line 466 of file Matrix.cpp.

◆ CollectDiscreteKeys()

DiscreteKeys gtsam::CollectDiscreteKeys	(	const DiscreteKeys &	key1,
		const DiscreteKeys &	key2
	)

Definition at line 43 of file HybridFactor.cpp.

◆ collectKeyDim()

template<class LinearGraph >

KeyDimMap gtsam::collectKeyDim ( const LinearGraph & linearGraph )

Definition at line 38 of file LP.h.

◆ CollectKeys() [1/2]

KeyVector gtsam::CollectKeys	(	const KeyVector &	continuousKeys,
		const DiscreteKeys &	discreteKeys
	)

Definition at line 23 of file HybridFactor.cpp.

◆ CollectKeys() [2/2]

KeyVector gtsam::CollectKeys	(	const KeyVector &	keys1,
		const KeyVector &	keys2
	)

Definition at line 35 of file HybridFactor.cpp.

◆ column()

template<class MATRIX >

const MATRIX::ConstColXpr gtsam::column	(	const MATRIX &	A,
		size_t	j
	)

Extracts a column view from a matrix that avoids a copy

Parameters

A	matrix to extract column from
j	index of the column

Returns: a const view of the matrix

Definition at line 210 of file base/Matrix.h.

◆ columnNormSquare()

GTSAM_EXPORT Vector gtsam::columnNormSquare ( const Matrix & A )

Definition at line 223 of file Matrix.cpp.

◆ compose()

template<typename T >

Expression<T> gtsam::compose	(	const Expression< T > &	t1,
		const Expression< T > &	t2
	)

Definition at line 23 of file nonlinear/expressions.h.

◆ composePoses()

template<class G , class Factor , class POSE , class KEY >

std::shared_ptr<Values> gtsam::composePoses	(	const G &	graph,
		const PredecessorMap< KEY > &	tree,
		const POSE &	rootPose
	)

Compose the poses by following the chain specified by the spanning tree

Definition at line 167 of file graph-inl.h.

◆ ComputeLeafOrdering()

std::vector<double> gtsam::ComputeLeafOrdering	(	const DiscreteKeys &	dkeys,
		const DecisionTreeFactor &	dt
	)

Compute the correct ordering of the leaves in the decision tree.

This is done by first taking all the values which have modulo 0 value with the cardinality of the innermost key n, and we go up to modulo n.

Parameters

dt	The DecisionTree

Returns: std::vector<double>

Definition at line 73 of file TableFactor.cpp.

◆ concatVectors() [1/2]

Vector gtsam::concatVectors ( const std::list< Vector > & vs )

concatenate Vectors

Definition at line 301 of file Vector.cpp.

◆ concatVectors() [2/2]

Vector gtsam::concatVectors	(	size_t	nrVectors,
			...
	)

concatenate Vectors

Definition at line 316 of file Vector.cpp.

◆ conjugateGradientDescent() [1/3]

VectorValues gtsam::conjugateGradientDescent	(	const GaussianFactorGraph &	fg,
		const VectorValues &	x,
		const ConjugateGradientParameters &	parameters
	)

Method of conjugate gradients (CG), Gaussian Factor Graph version

Definition at line 70 of file iterative.cpp.

◆ conjugateGradientDescent() [2/3]

Vector gtsam::conjugateGradientDescent	(	const Matrix &	A,
		const Vector &	b,
		const Vector &	x,
		const ConjugateGradientParameters &	parameters
	)

Method of conjugate gradients (CG), Matrix version

Definition at line 57 of file iterative.cpp.

◆ conjugateGradientDescent() [3/3]

Vector gtsam::conjugateGradientDescent	(	const System &	Ab,
		const Vector &	x,
		const ConjugateGradientParameters &	parameters
	)

Method of conjugate gradients (CG), System version

Definition at line 45 of file iterative.cpp.

◆ conjugateGradients()

template<class S , class V , class E >

V gtsam::conjugateGradients	(	const S &	Ab,
		V	x,
		const ConjugateGradientParameters &	parameters,
		bool	steepest = `false`
	)

Method of conjugate gradients (CG) template "System" class S needs gradient(S,v), e=S*v, v=S^e "Vector" class V needs dot(v,v), -v, v+v, s*v "Vector" class E needs dot(v,v)

Parameters

Ab,the	"system" that needs to be solved, examples below
x	is the initial estimate
steepest	flag, if true does steepest descent, not CG

Definition at line 126 of file iterative-inl.h.

◆ ConnectVariableFactor()

static void gtsam::ConnectVariableFactor	(	Key	key,
		const KeyFormatter &	keyFormatter,
		size_t	i,
		ostream *	os
	)

static

Definition at line 72 of file DotWriter.cpp.

◆ ConnectVariables()

static void gtsam::ConnectVariables	(	Key	key1,
		Key	key2,
		const KeyFormatter &	keyFormatter,
		ostream *	os
	)

static

Definition at line 66 of file DotWriter.cpp.

◆ continuousElimination()

static std::pair<HybridConditional::shared_ptr, std::shared_ptr<Factor> > gtsam::continuousElimination	(	const HybridGaussianFactorGraph &	factors,
		const Ordering &	frontalKeys
	)

static

Definition at line 219 of file HybridGaussianFactorGraph.cpp.

◆ convert() [1/3]

static BinaryMeasurement<Rot3> gtsam::convert ( const BetweenFactor< Pose3 >::shared_ptr & f )

static

Definition at line 993 of file ShonanAveraging.cpp.

◆ convert() [2/3]

static BinaryMeasurement<Rot2> gtsam::convert ( const BinaryMeasurement< Pose2 > & p )

static

Definition at line 409 of file dataset.cpp.

◆ convert() [3/3]

static BinaryMeasurement<Rot3> gtsam::convert ( const BinaryMeasurement< Pose3 > & p )

static

Definition at line 882 of file dataset.cpp.

◆ ConvertNoiseModel()

SharedNoiseModel gtsam::ConvertNoiseModel	(	const SharedNoiseModel &	model,
		size_t	n,
		bool	defaultToUnit = `true`
	)

When creating (any) FrobeniusFactor we can convert a Rot/Pose BetweenFactor noise model into a n-dimensional isotropic noise model used to weight the Frobenius norm. If the noise model passed is null we return a n-dimensional isotropic noise model with sigma=1.0. If not, we we check if the d-dimensional noise model on rotations is isotropic. If it is, we extend to 'n' dimensions, otherwise we throw an error. If the noise model is a robust error model, we use the sigmas of the underlying noise model.

If defaultToUnit == false throws an exception on unexepcted input.

Definition at line 27 of file FrobeniusFactor.cpp.

◆ convertPose2ToBinaryMeasurementRot2()

static BinaryMeasurement<Rot2> gtsam::convertPose2ToBinaryMeasurementRot2 ( const BetweenFactor< Pose2 >::shared_ptr & f )

static

Definition at line 945 of file ShonanAveraging.cpp.

◆ convertToJacobianFactors()

static GaussianFactorGraph gtsam::convertToJacobianFactors ( const GaussianFactorGraph & gfg )

static

Definition at line 77 of file SubgraphPreconditioner.cpp.

◆ createDiscreteFactor()

static std::shared_ptr<Factor> gtsam::createDiscreteFactor	(	const ResultTree &	eliminationResults,
		const DiscreteKeys &	discreteSeparator
	)

static

Compute the probability p(μ;m) = exp(-error(μ;m)) * sqrt(det(2π Σ_m) from the residual error ||b||^2 at the mean μ. The residual error contains no keys, and only depends on the discrete separator if present.

Definition at line 304 of file HybridGaussianFactorGraph.cpp.

◆ createErrors()

Errors gtsam::createErrors ( const VectorValues & V )

Break V into pieces according to its start indices.

Definition at line 28 of file Errors.cpp.

◆ createHybridGaussianFactor()

static std::shared_ptr<Factor> gtsam::createHybridGaussianFactor	(	const ResultTree &	eliminationResults,
		const DiscreteKeys &	discreteSeparator
	)

static

Definition at line 329 of file HybridGaussianFactorGraph.cpp.

◆ createNoiseModel()

static SharedNoiseModel gtsam::createNoiseModel	(	const Vector6 &	v,
		bool	smart,
		NoiseFormat	noiseFormat,
		KernelFunctionType	kernelFunctionType
	)

static

Definition at line 216 of file dataset.cpp.

◆ createPinholeCalibration()

template<class CALIBRATION >

Cal3_S2 gtsam::createPinholeCalibration ( const CALIBRATION & cal )

Create a pinhole calibration from a different Cal3 object, removing distortion.

Template Parameters

CALIBRATION Original calibration object.

Parameters

cal	Input calibration object.

Returns: Cal3_S2 with only the pinhole elements of cal.

Definition at line 253 of file triangulation.h.

◆ createPoints()

std::vector<Point3> gtsam::createPoints ( )

Create a set of ground-truth landmarks.

Definition at line 43 of file SFMdata.h.

◆ createPoses()

std::vector<Pose3> gtsam::createPoses	(	const Pose3 &	init = `Pose3(Rot3::Ypr(M_PI_2, 0, -M_PI_2), {30, 0, 0})`,
		const Pose3 &	delta = `Pose3(Rot3::Ypr(0, -M_PI_4, 0), {sin(M_PI_4) * 30, 0, 30 * (1 - sin(M_PI_4))})`,
		int	steps = `8`
	)

Create a set of ground-truth poses Default values give a circular trajectory, radius 30 at pi/4 intervals, always facing the circle center

Definition at line 62 of file SFMdata.h.

◆ createPreconditioner()

std::shared_ptr< Preconditioner > gtsam::createPreconditioner ( const std::shared_ptr< PreconditionerParameters > params )

Definition at line 189 of file Preconditioner.cpp.

◆ createRewrittenFileName()

std::string gtsam::createRewrittenFileName ( const std::string & name )

Creates a temporary file name that needs to be ignored in .gitingnore for checking read-write oprations

Definition at line 105 of file dataset.cpp.

◆ createSampler()

std::shared_ptr<Sampler> gtsam::createSampler ( const SharedNoiseModel & model )

Definition at line 383 of file dataset.cpp.

◆ createUnknowns()

template<typename T >

std::vector<Expression<T> > gtsam::createUnknowns	(	size_t	n,
		char	c,
		size_t	start = `0`
	)

Construct an array of leaves.

Construct an array of unknown expressions with successive symbol keys Example: createUnknowns<Pose2>(3,'x') creates unknown expressions for x0,x1,x2

Definition at line 283 of file Expression-inl.h.

◆ cross() [1/2]

Point3 gtsam::cross	(	const Point3 &	p,
		const Point3 &	q,
		OptionalJacobian< 3, 3 >	H_p = `{}`,
		OptionalJacobian< 3, 3 >	H_q = `{}`
	)

cross product

Returns: this x q

Definition at line 64 of file Point3.cpp.

◆ cross() [2/2]

Point3_ gtsam::cross	(	const Point3_ &	a,
		const Point3_ &	b
	)

inline

Definition at line 66 of file slam/expressions.h.

◆ D2dcalibration()

static Matrix29 gtsam::D2dcalibration	(	double	x,
		double	y,
		double	xx,
		double	yy,
		double	xy,
		double	rr,
		double	r4,
		double	pnx,
		double	pny,
		const Matrix2 &	DK
	)

static

Definition at line 57 of file Cal3DS2_Base.cpp.

◆ D2dintrinsic()

static Matrix2 gtsam::D2dintrinsic	(	double	x,
		double	y,
		double	rr,
		double	g,
		double	k1,
		double	k2,
		double	p1,
		double	p2,
		const Matrix2 &	DK
	)

static

Definition at line 71 of file Cal3DS2_Base.cpp.

◆ DaiYuan()

template<typename Gradient >

double gtsam::DaiYuan	(	const Gradient &	currentGradient,
		const Gradient &	prevGradient,
		const Gradient &	direction
	)

The Dai-Yuan formula for computing β, the direction of steepest descent.

Definition at line 63 of file NonlinearConjugateGradientOptimizer.h.

◆ demangle()

std::string gtsam::demangle ( const char * name )

Pretty print Value type name.

Function to demangle type name of variable, e.g. demangle(typeid(x).name())

Definition at line 37 of file types.cpp.

◆ deserializeGraph()

NonlinearFactorGraph::shared_ptr gtsam::gtsam::deserializeGraph ( const std::string & serialized_graph )

Definition at line 184 of file serialization.cpp.

◆ deserializeGraphFromFile()

NonlinearFactorGraph::shared_ptr gtsam::gtsam::deserializeGraphFromFile ( const std::string & fname )

Definition at line 251 of file serialization.cpp.

◆ deserializeGraphFromXMLFile()

NonlinearFactorGraph::shared_ptr gtsam::gtsam::deserializeGraphFromXMLFile	(	const std::string &	fname,
		const std::string &	name = `"graph"`
	)

Definition at line 259 of file serialization.cpp.

◆ deserializeGraphXML()

NonlinearFactorGraph::shared_ptr gtsam::gtsam::deserializeGraphXML	(	const std::string &	serialized_graph,
		const std::string &	name = `"graph"`
	)

Definition at line 196 of file serialization.cpp.

◆ deserializeValues()

Values::shared_ptr gtsam::gtsam::deserializeValues ( const std::string & serialized_values )

Definition at line 209 of file serialization.cpp.

◆ deserializeValuesFromFile()

Values::shared_ptr gtsam::gtsam::deserializeValuesFromFile ( const std::string & fname )

Definition at line 268 of file serialization.cpp.

◆ deserializeValuesFromXMLFile()

Values::shared_ptr gtsam::gtsam::deserializeValuesFromXMLFile	(	const std::string &	fname,
		const std::string &	name = `"values"`
	)

Definition at line 276 of file serialization.cpp.

◆ deserializeValuesXML()

Values::shared_ptr gtsam::gtsam::deserializeValuesXML	(	const std::string &	serialized_values,
		const std::string &	name = `"values"`
	)

Definition at line 221 of file serialization.cpp.

◆ diag()

Matrix gtsam::diag ( const std::vector< Matrix > & Hs )

Create a matrix with submatrices along its diagonal

Definition at line 206 of file Matrix.cpp.

◆ Diagonal()

static noiseModel::Diagonal::shared_ptr gtsam::Diagonal ( const Matrix & covariance )

static

Definition at line 27 of file ScenarioRunner.h.

◆ discreteElimination()

static std::pair<HybridConditional::shared_ptr, std::shared_ptr<Factor> > gtsam::discreteElimination	(	const HybridGaussianFactorGraph &	factors,
		const Ordering &	frontalKeys
	)

static

Definition at line 260 of file HybridGaussianFactorGraph.cpp.

◆ DiscreteFactorFromErrors()

static DecisionTreeFactor::shared_ptr gtsam::DiscreteFactorFromErrors	(	const DiscreteKeys &	discreteKeys,
		const AlgebraicDecisionTree< Key > &	errors
	)

static

Take negative log-values, shift them so that the minimum value is 0, and then exponentiate to create a DecisionTreeFactor (not normalized yet!).

Parameters

errors DecisionTree of (unnormalized) errors.

Returns: DecisionTreeFactor::shared_ptr

Definition at line 249 of file HybridGaussianFactorGraph.cpp.

◆ DiscreteKeysAsSet()

std::set<DiscreteKey> gtsam::DiscreteKeysAsSet ( const DiscreteKeys & discreteKeys )

Return the DiscreteKey vector as a set.

Definition at line 298 of file HybridGaussianConditional.cpp.

◆ distance()

Double_ gtsam::distance ( const OrientedPlane3_ & p )

inline

Definition at line 117 of file slam/expressions.h.

◆ distance2()

double gtsam::distance2	(	const Point2 &	p,
		const Point2 &	q,
		OptionalJacobian< 1, 2 >	H1,
		OptionalJacobian< 1, 2 >	H2
	)

distance between two points

Definition at line 39 of file Point2.cpp.

◆ distance3()

double gtsam::distance3	(	const Point3 &	p1,
		const Point3 &	q,
		OptionalJacobian< 1, 3 >	H1,
		OptionalJacobian< 1, 3 >	H2
	)

distance between two points

Definition at line 27 of file Point3.cpp.

◆ DLT()

std::tuple<int, double, Vector> gtsam::DLT	(	const Matrix &	A,
		double	rank_tol = `1e-9`
	)

Direct linear transform algorithm that calls svd to find a vector v that minimizes the algebraic error A*v

Parameters

A	of size mn, where m>=n (pad with zero rows if not!) Returns rank of A, minimum error (singular value), and corresponding eigenvector (column of V, with A=US*V')

Definition at line 566 of file Matrix.cpp.

◆ dot() [1/4]

double gtsam::dot	(	const Errors &	a,
		const Errors &	b
	)

Dot product.

Definition at line 96 of file Errors.cpp.

◆ dot() [2/4]

double gtsam::dot	(	const Point3 &	p,
		const Point3 &	q,
		OptionalJacobian< 1, 3 >	H1,
		OptionalJacobian< 1, 3 >	H2
	)

dot product

Definition at line 72 of file Point3.cpp.

◆ dot() [3/4]

Double_ gtsam::dot	(	const Point3_ &	a,
		const Point3_ &	b
	)

inline

Definition at line 72 of file slam/expressions.h.

◆ dot() [4/4]

template<class V1 , class V2 >

double gtsam::dot	(	const V1 &	a,
		const V2 &	b
	)

inline

Dot product

Definition at line 195 of file Vector.h.

◆ ediv_()

Vector gtsam::ediv_	(	const Vector &	a,
		const Vector &	b
	)

elementwise division, but 0/0 = 0, not inf

Parameters

a	first vector
b	second vector

Returns: vector [a(i)/b(i)]

Definition at line 198 of file Vector.cpp.

◆ EliminateQR()

std::pair<GaussianConditional::shared_ptr, JacobianFactor::shared_ptr> gtsam::EliminateQR	(	const GaussianFactorGraph &	factors,
		const Ordering &	keys
	)

Multiply all factors and eliminate the given keys from the resulting factor using a QR variant that handles constraints (zero sigmas). Computation happens in noiseModel::Gaussian::QR Returns a conditional on those keys, and a new factor on the separator.

Definition at line 778 of file JacobianFactor.cpp.

◆ EliminateSymbolic()

std::pair<std::shared_ptr<SymbolicConditional>, std::shared_ptr<SymbolicFactor> > gtsam::EliminateSymbolic	(	const SymbolicFactorGraph &	factors,
		const Ordering &	keys
	)

Dense elimination function for symbolic factors. This is usually provided as an argument to one of the factor graph elimination functions (see EliminateableFactorGraph). The factor graph elimination functions do sparse variable elimination, and use this function to eliminate single variables or variable cliques.

Definition at line 36 of file SymbolicFactor.cpp.

◆ EpipolarTransfer()

Point2 gtsam::EpipolarTransfer	(	const Matrix3 &	Fca,
		const Point2 &	pa,
		const Matrix3 &	Fcb,
		const Point2 &	pb
	)

Transfer projections from cameras a and b to camera c.

Take two fundamental matrices Fca and Fcb, and two points pa and pb, and returns the 2D point in view (c) where the epipolar lines intersect.

Definition at line 15 of file FundamentalMatrix.cpp.

◆ equal() [1/4]

template<class T >

bool gtsam::equal	(	const T &	obj1,
		const T &	obj2
	)

inline

Call equal without tolerance (use default tolerance)

Definition at line 91 of file Testable.h.

◆ equal() [2/4]

template<class T >

bool gtsam::equal	(	const T &	obj1,
		const T &	obj2,
		double	tol
	)

inline

Call equal on the object

Definition at line 85 of file Testable.h.

◆ equal() [3/4]

bool gtsam::equal	(	const Vector &	vec1,
		const Vector &	vec2
	)

inline

Override of equal in Lie.h

Definition at line 142 of file Vector.h.

◆ equal() [4/4]

bool gtsam::equal	(	const Vector &	vec1,
		const Vector &	vec2,
		double	tol
	)

inline

Override of equal in Lie.h

Definition at line 135 of file Vector.h.

◆ equal_with_abs_tol() [1/3]

template<class MATRIX >

bool gtsam::equal_with_abs_tol	(	const Eigen::DenseBase< MATRIX > &	A,
		const Eigen::DenseBase< MATRIX > &	B,
		double	tol = `1e-9`
	)

equals with a tolerance

Definition at line 80 of file base/Matrix.h.

◆ equal_with_abs_tol() [2/3]

GTSAM_EXPORT bool gtsam::equal_with_abs_tol	(	const SubVector &	vec1,
		const SubVector &	vec2,
		double	tol
	)

Definition at line 133 of file Vector.cpp.

◆ equal_with_abs_tol() [3/3]

bool gtsam::equal_with_abs_tol	(	const Vector &	vec1,
		const Vector &	vec2,
		double	tol = `1e-9`
	)

VecA == VecB up to tolerance

Definition at line 122 of file Vector.cpp.

◆ equality()

GTSAM_EXPORT bool gtsam::equality	(	const Errors &	actual,
		const Errors &	expected,
		double	tol
	)

Definition at line 52 of file Errors.cpp.

◆ expm() [1/2]

Matrix gtsam::expm	(	const Matrix &	A,
		size_t	K = `7`
	)

Numerical exponential map, naive approach, not industrial strength !!!

Parameters

A	matrix to exponentiate
K	number of iterations

Definition at line 587 of file Matrix.cpp.

◆ expm() [2/2]

template<class T >

T gtsam::expm	(	const Vector &	x,
		int	K = `7`
	)

Exponential map given exponential coordinates class T needs a wedge<> function and a constructor from Matrix

Parameters

x	exponential coordinates, vector of size n @ return a T

Definition at line 317 of file Lie.h.

◆ expmap_default()

template<class Class >

Class gtsam::expmap_default	(	const Class &	t,
		const Vector &	d
	)

inline

Exponential map centered at l0, s.t. exp(t,d) = t*exp(d)

Definition at line 252 of file Lie.h.

◆ expNormalize()

std::vector<double> gtsam::expNormalize ( const std::vector< double > & logProbs )

Normalize a set of log probabilities.

Normalizing a set of log probabilities in a numerically stable way is tricky. To avoid overflow/underflow issues, we compute the largest (finite) log probability and subtract it from each log probability before normalizing. This comes from the observation that if: p_i = exp(L_i) / ( sum_j exp(L_j) ), Then, p_i = exp(Z) exp(L_i - Z) / (exp(Z) sum_j exp(L_j - Z)), = exp(L_i - Z) / ( sum_j exp(L_j - Z) )

Setting Z = max_j L_j, we can avoid numerical issues that arise when all of the (unnormalized) log probabilities are either very large or very small.

Definition at line 70 of file DiscreteFactor.cpp.

◆ extractRot2Measurements()

static ShonanAveraging2::Measurements gtsam::extractRot2Measurements ( const BetweenFactorPose2s & factors )

static

Definition at line 961 of file ShonanAveraging.cpp.

◆ extractRot3Measurements()

static ShonanAveraging3::Measurements gtsam::extractRot3Measurements ( const BetweenFactorPose3s & factors )

static

Definition at line 1009 of file ShonanAveraging.cpp.

◆ findExampleDataFile()

std::string gtsam::findExampleDataFile ( const std::string & name )

Find the full path to an example dataset distributed with gtsam. The name may be specified with or without a file extension - if no extension is given, this function first looks for the .graph extension, then .txt. We first check the gtsam source tree for the file, followed by the installed example dataset location. Both the source tree and installed locations are obtained from CMake during compilation.

Returns: The full path and filename to the requested dataset.

Exceptions

std::invalid_argument if no matching file could be found using the search process described above.

Definition at line 70 of file dataset.cpp.

◆ FindKarcherMean() [1/3]

template<class T >

T gtsam::FindKarcherMean ( const std::vector< T > & rotations )

Definition at line 45 of file KarcherMeanFactor-inl.h.

◆ FindKarcherMean() [2/3]

template<class T >

T gtsam::FindKarcherMean ( const std::vector< T, Eigen::aligned_allocator< T >> & rotations )

Optimize for the Karcher mean, minimizing the geodesic distance to each of the given rotations, by constructing a factor graph out of simple PriorFactors.

Definition at line 50 of file KarcherMeanFactor-inl.h.

◆ FindKarcherMean() [3/3]

template<class T >

T gtsam::FindKarcherMean ( std::initializer_list< T > && rotations )

Definition at line 55 of file KarcherMeanFactor-inl.h.

◆ FindKarcherMeanImpl()

template<class T , class ALLOC >

T gtsam::FindKarcherMeanImpl ( const vector< T, ALLOC > & rotations )

Definition at line 30 of file KarcherMeanFactor-inl.h.

◆ findMinimumSpanningTree()

template<class G , class KEY , class FACTOR2 >

PredecessorMap<KEY> gtsam::findMinimumSpanningTree ( const G & g )

find the minimum spanning tree using boost graph library

Definition at line 222 of file graph-inl.h.

◆ FletcherReeves()

template<typename Gradient >

double gtsam::FletcherReeves	(	const Gradient &	currentGradient,
		const Gradient &	prevGradient
	)

Fletcher-Reeves formula for computing β, the direction of steepest descent.

Definition at line 30 of file NonlinearConjugateGradientOptimizer.h.

◆ formatMatrixIndented()

std::string gtsam::formatMatrixIndented	(	const std::string &	label,
		const Matrix &	matrix,
		bool	makeVectorHorizontal
	)

Definition at line 597 of file Matrix.cpp.

◆ fpEqual()

bool gtsam::fpEqual	(	double	a,
		double	b,
		double	tol,
		bool	check_relative_also = `true`
	)

Ensure we are not including a different version of Eigen in user code than while compiling gtsam, since it can lead to hard-to-understand runtime crashes. Numerically stable function for comparing if floating point values are equal within epsilon tolerance. Used for vector and matrix comparison with C++11 compatible functions.

If either value is NaN or Inf, we check for both values to be NaN or Inf respectively for the comparison to be true. If one is NaN/Inf and the other is not, returns false.

Parameters

check_relative_also is a flag which toggles additional checking for relative error. This means that if either the absolute error or the relative error is within the tolerance, the result will be true. By default, the flag is true.

Return true if two numbers are close wrt tol.

Definition at line 41 of file Vector.cpp.

◆ G3()

static std::vector<Matrix3> gtsam::G3 ( {SO3::Hat(Vector3::Unit(0)), SO3::Hat(Vector3::Unit(1)), SO3::Hat(Vector3::Unit(2))} )

static

◆ G4()

static std::vector<Matrix4, Eigen::aligned_allocator<Matrix4> > gtsam::G4 ( {SO4::Hat(Vector6::Unit(0)), SO4::Hat(Vector6::Unit(1)), SO4::Hat(Vector6::Unit(2)), SO4::Hat(Vector6::Unit(3)), SO4::Hat(Vector6::Unit(4)), SO4::Hat(Vector6::Unit(5))} )

static

◆ genericValue()

template<class T >

GenericValue<T> gtsam::genericValue ( const T & v )

Functional constructor of GenericValue<T> so T can be automatically deduced

Definition at line 211 of file GenericValue.h.

◆ GetCategory()

HybridFactor::Category gtsam::GetCategory	(	const KeyVector &	continuousKeys,
		const DiscreteKeys &	discreteKeys
	)

Definition at line 56 of file HybridFactor.cpp.

◆ getPose()

template<class CALIBRATION >

Pose3_ gtsam::getPose ( const Expression< PinholeCamera< CALIBRATION > > & cam )

inline

Definition at line 177 of file slam/expressions.h.

◆ getSubvector()

static Vector gtsam::getSubvector	(	const Vector &	src,
		const KeyInfo &	keyInfo,
		const KeyVector &	keys
	)

static

Definition at line 37 of file SubgraphPreconditioner.cpp.

◆ gradientInPlace()

static VectorValues gtsam::gradientInPlace	(	const NonlinearFactorGraph &	nfg,
		const Values &	values
	)

static

Return the gradient vector of a nonlinear factor graph.

Parameters

nfg	the graph
values	a linearization point Can be moved to NonlinearFactorGraph.h if desired

Definition at line 37 of file NonlinearConjugateGradientOptimizer.cpp.

◆ greaterThanOrEqual()

bool gtsam::greaterThanOrEqual	(	const Vector &	v1,
		const Vector &	v2
	)

Greater than or equal to operation returns true if all elements in v1 are greater than corresponding elements in v2

Definition at line 113 of file Vector.cpp.

◆ gtsam2openGL() [1/2]

Pose3 gtsam::gtsam2openGL ( const Pose3 & PoseGTSAM )

This function converts a GTSAM camera pose to an openGL camera pose.

Parameters

PoseGTSAM pose in GTSAM format

Returns: Pose3 in openGL format

Definition at line 96 of file SfmData.cpp.

◆ gtsam2openGL() [2/2]

Pose3 gtsam::gtsam2openGL	(	const Rot3 &	R,
		double	tx,
		double	ty,
		double	tz
	)

This function converts a GTSAM camera pose to an openGL camera pose.

Parameters

R	rotation in GTSAM
tx	x component of the translation in GTSAM
ty	y component of the translation in GTSAM
tz	z component of the translation in GTSAM

Returns: Pose3 in openGL format

Definition at line 88 of file SfmData.cpp.

◆ GTSAM_CONCEPT_REQUIRES() [1/2]

template<typename G >

gtsam::GTSAM_CONCEPT_REQUIRES	(	IsGroup< G >	,
		bool
	)		const &

Check invariants.

◆ GTSAM_CONCEPT_REQUIRES() [2/2]

template<typename T >

gtsam::GTSAM_CONCEPT_REQUIRES	(	IsTestable< T >	,
		bool
	)		const &

Check invariants for Manifold type.

◆ guardedIsDebug()

bool GTSAM_EXPORT gtsam::guardedIsDebug ( const std::string & s )

Definition at line 35 of file debug.cpp.

◆ guardedSetDebug()

void GTSAM_EXPORT gtsam::guardedSetDebug	(	const std::string &	s,
		const bool	v
	)

Definition at line 43 of file debug.cpp.

◆ hasConstraints()

bool gtsam::hasConstraints ( const GaussianFactorGraph & factors )

Evaluates whether linear factors have any constrained noise models

Returns: true if any factor is constrained.

Definition at line 442 of file GaussianFactorGraph.cpp.

◆ HestenesStiefel()

template<typename Gradient >

double gtsam::HestenesStiefel	(	const Gradient &	currentGradient,
		const Gradient &	prevGradient,
		const Gradient &	direction
	)

The Hestenes-Stiefel formula for computing β, the direction of steepest descent.

Definition at line 52 of file NonlinearConjugateGradientOptimizer.h.

◆ house()

pair<double, Vector > gtsam::house ( const Vector & x )

house(x,j) computes HouseHolder vector v and scaling factor beta from x, such that the corresponding Householder reflection zeroes out all but x.(j), j is base 0. Golub & Van Loan p 210.

Definition at line 236 of file Vector.cpp.

◆ householder()

void gtsam::householder	(	Matrix &	A,
		size_t	k
	)

Householder tranformation, zeros below diagonal

Parameters

k	number of columns to zero out below diagonal
A	matrix

Returns: nothing: in place !!!

Definition at line 352 of file Matrix.cpp.

◆ householder_()

void gtsam::householder_	(	Matrix &	A,
		size_t	k,
		bool	copy_vectors
	)

Imperative version of Householder QR factorization, Golub & Van Loan p 224 version with Householder vectors below diagonal, as in GVL

Householder transformation, Householder vectors below diagonal

Parameters

k	number of columns to zero out below diagonal
A	matrix
copy_vectors	- true to copy Householder vectors below diagonal

Returns: nothing: in place !!!

Definition at line 325 of file Matrix.cpp.

◆ houseInPlace()

double gtsam::houseInPlace ( Vector & x )

beta = house(x) computes the HouseHolder vector in place

Definition at line 211 of file Vector.cpp.

◆ html()

string gtsam::html	(	const DiscreteValues &	values,
		const KeyFormatter &	keyFormatter,
		const DiscreteValues::Names &	names
	)

Free version of html.

Definition at line 135 of file DiscreteValues.cpp.

◆ HybridOrdering()

const Ordering gtsam::HybridOrdering ( const HybridGaussianFactorGraph & graph )

Return a Colamd constrained ordering where the discrete keys are eliminated after the continuous keys.

Returns: const Ordering

Definition at line 87 of file HybridGaussianFactorGraph.cpp.

◆ IndexPairSetAsArray()

IndexPairVector gtsam::IndexPairSetAsArray ( IndexPairSet & set )

inline

Definition at line 128 of file DSFMap.h.

◆ initialCamerasAndPointsEstimate()

Values gtsam::initialCamerasAndPointsEstimate ( const SfmData & db )

This function creates initial values for cameras and points from db.

Note: Pose keys are simply integer indices, points use Symbol('p', j).

Parameters

SfmData

Returns: Values

Definition at line 430 of file SfmData.cpp.

◆ initialCamerasEstimate()

Values gtsam::initialCamerasEstimate ( const SfmData & db )

This function creates initial values for cameras from db.

No symbol is used, so camera keys are simply integer indices.

Parameters

SfmData

Returns: Values

Definition at line 422 of file SfmData.cpp.

◆ inner_prod()

template<class V1 , class V2 >

double gtsam::inner_prod	(	const V1 &	a,
		const V2 &	b
	)

inline

compatibility version for ublas' inner_prod()

Definition at line 202 of file Vector.h.

◆ inplace_QR()

void gtsam::inplace_QR ( Matrix & A )

QR factorization using Eigen's internal block QR algorithm

Parameters

A	is the input matrix, and is the output
clear_below_diagonal	enables zeroing out below diagonal

Definition at line 636 of file Matrix.cpp.

◆ insertSub()

template<typename Derived1 , typename Derived2 >

void gtsam::insertSub	(	Eigen::MatrixBase< Derived1 > &	fullMatrix,
		const Eigen::MatrixBase< Derived2 > &	subMatrix,
		size_t	i,
		size_t	j
	)

insert a submatrix IN PLACE at a specified location in a larger matrix NOTE: there is no size checking

Parameters

fullMatrix	matrix to be updated
subMatrix	matrix to be inserted
i	is the row of the upper left corner insert location
j	is the column of the upper left corner insert location

Definition at line 194 of file base/Matrix.h.

◆ interpolate()

template<typename T >

T gtsam::interpolate	(	const T &	X,
		const T &	Y,
		double	t,
		typename MakeOptionalJacobian< T, T >::type	Hx = `{}`,
		typename MakeOptionalJacobian< T, T >::type	Hy = `{}`
	)

Linear interpolation between X and Y by coefficient t. Typically t \in [0,1], but can also be used to extrapolate before pose X or after pose Y.

Definition at line 327 of file Lie.h.

◆ inverse_square_root()

Matrix gtsam::inverse_square_root ( const Matrix & A )

Use Cholesky to calculate inverse square root of a matrix

Definition at line 550 of file Matrix.cpp.

◆ is_linear_dependent()

static bool gtsam::is_linear_dependent	(	const Matrix &	A,
		const Matrix &	B,
		double	tol
	)

static

Definition at line 82 of file Matrix.cpp.

◆ isDebugVersion()

bool GTSAM_EXPORT gtsam::isDebugVersion ( )

Definition at line 50 of file debug.cpp.

◆ Kappa()

template<typename T , size_t d>

static double gtsam::Kappa	(	const BinaryMeasurement< T > &	measurement,
		const ShonanAveragingParameters< d > &	parameters
	)

static

Definition at line 331 of file ShonanAveraging.cpp.

◆ kRandomNumberGenerator()

static std::mt19937 gtsam::kRandomNumberGenerator ( 42 )

static

◆ linear_dependent() [1/2]

bool gtsam::linear_dependent	(	const Matrix &	A,
		const Matrix &	B,
		double	tol = `1e-9`
	)

check whether the rows of two matrices are linear dependent

Definition at line 114 of file Matrix.cpp.

◆ linear_dependent() [2/2]

bool gtsam::linear_dependent	(	const Vector &	vec1,
		const Vector &	vec2,
		double	tol = `1e-9`
	)

check whether two vectors are linearly dependent

Parameters

vec1	Vector
vec2	Vector
tol	1e-9

Returns: bool

Definition at line 180 of file Vector.cpp.

◆ linear_independent()

bool gtsam::linear_independent	(	const Matrix &	A,
		const Matrix &	B,
		double	tol = `1e-9`
	)

check whether the rows of two matrices are linear independent

Definition at line 100 of file Matrix.cpp.

◆ linearExpression()

template<typename T , typename A >

Expression<T> gtsam::linearExpression	(	const std::function< T(A)> &	f,
		const Expression< A > &	expression,
		const Eigen::Matrix< double, traits< T >::dimension, traits< A >::dimension > &	dTdA
	)

Create an expression out of a linear function f:T->A with (constant) Jacobian dTdA TODO(frank): create a more efficient version like ScalarMultiplyExpression. This version still does a malloc every linearize.

Definition at line 247 of file Expression.h.

◆ linearizeNumerically()

JacobianFactor gtsam::linearizeNumerically	(	const NoiseModelFactor &	factor,
		const Values &	values,
		double	delta = `1e-5`
	)

inline

Linearize a nonlinear factor using numerical differentiation The benefit of this method is that it does not need to know what types are involved to evaluate the factor. If all the machinery of gtsam is working correctly, we should get the correct numerical derivatives out the other side. NOTE(frank): factors that have non vector-space measurements use between or LocalCoordinates to evaluate the error, and their derivatives will only be correct for near-zero errors. This is fixable but expensive, and does not matter in practice as most factors will sit near zero errors anyway. However, it means that below will only be exact for the correct measurement.

Definition at line 39 of file factorTesting.h.

◆ lineSearch()

template<class S , class V , class W >

double gtsam::lineSearch	(	const S &	system,
		const V	currentValues,
		const W &	gradient
	)

Implement the golden-section line search algorithm

Definition at line 136 of file NonlinearConjugateGradientOptimizer.h.

◆ LLt()

GTSAM_EXPORT Matrix gtsam::LLt ( const Matrix & A )

Definition at line 521 of file Matrix.cpp.

◆ load2D() [1/2]

GraphAndValues gtsam::load2D	(	const std::string &	filename,
		SharedNoiseModel	model = `SharedNoiseModel()`,
		size_t	maxIndex = `0`,
		bool	addNoise = `false`,
		bool	smart = `true`,
		NoiseFormat	noiseFormat = `NoiseFormatAUTO`,
		KernelFunctionType	kernelFunctionType = `KernelFunctionTypeNONE`
	)

Load TORO/G2O style graph files

Parameters

filename
model	optional noise model to use instead of one specified by file
maxIndex	if non-zero cut out vertices >= maxIndex
addNoise	add noise to the edges
smart	try to reduce complexity of covariance to cheapest model
noiseFormat	how noise parameters are stored
kernelFunctionType	whether to wrap the noise model in a robust kernel

Returns: graph and initial values

Definition at line 505 of file dataset.cpp.

◆ load2D() [2/2]

GraphAndValues gtsam::load2D	(	std::pair< std::string, SharedNoiseModel >	dataset,
		size_t	maxIndex = `0`,
		bool	addNoise = `false`,
		bool	smart = `true`,
		NoiseFormat	noiseFormat = `NoiseFormatAUTO`,
		KernelFunctionType	kernelFunctionType = `KernelFunctionTypeNONE`
	)

Load TORO 2D Graph

Parameters

dataset/model	pair as constructed by [dataset]
maxIndex	if non-zero cut out vertices >= maxIndex
addNoise	add noise to the edges
smart	try to reduce complexity of covariance to cheapest model

Definition at line 572 of file dataset.cpp.

◆ load2D_robust()

GraphAndValues gtsam::load2D_robust	(	const std::string &	filename,
		const noiseModel::Base::shared_ptr &	model,
		size_t	maxIndex
	)

Definition at line 581 of file dataset.cpp.

◆ load3D()

GraphAndValues gtsam::load3D ( const std::string & filename )

Load TORO 3D Graph.

Definition at line 922 of file dataset.cpp.

◆ logmap()

template<typename T >

gtsam::Expression<typename gtsam::traits<T>::TangentVector> gtsam::logmap	(	const gtsam::Expression< T > &	x1,
		const gtsam::Expression< T > &	x2
	)

logmap

Definition at line 192 of file slam/expressions.h.

◆ logmap_default()

template<class Class >

Vector gtsam::logmap_default	(	const Class &	l0,
		const Class &	lp
	)

inline

Log map centered at l0, s.t. exp(l0,log(l0,lp)) = lp

Definition at line 246 of file Lie.h.

◆ make() [1/2]

static Symbol gtsam::make ( gtsam::Key key )

static

Definition at line 64 of file Symbol.cpp.

◆ make() [2/2]

static LabeledSymbol gtsam::make ( gtsam::Key key )

static

Definition at line 109 of file LabeledSymbol.cpp.

◆ make_shared() [1/2]

template<typename T , typename ... Args>

gtsam::enable_if_t<needs_eigen_aligned_allocator<T>::value, std::shared_ptr<T> > gtsam::make_shared ( Args &&... args )

Add our own make_shared as a layer of wrapping on std::make_shared This solves the problem with the stock make_shared that custom alignment is not respected, causing SEGFAULTs at runtime, which is notoriously hard to debug.

Explanation

The template needs_eigen_aligned_allocator<T>::value will evaluate to std::true_type if the type alias _eigen_aligned_allocator_trait = void is present in a class, which is automatically added by the GTSAM_MAKE_ALIGNED_OPERATOR_NEW macro.

This function declaration will only be taken when the above condition is true, so if some object does not need to be aligned, gtsam::make_shared will fall back to the next definition, which is a simple wrapper for std::make_shared.

Template Parameters

T	The type of object being constructed
Args	Type of the arguments of the constructor

Parameters

args	Arguments of the constructor

Returns: The object created as a std::shared_ptr<T>

Definition at line 56 of file make_shared.h.

◆ make_shared() [2/2]

template<typename T , typename ... Args>

gtsam::enable_if_t<!needs_eigen_aligned_allocator<T>::value, std::shared_ptr<T> > gtsam::make_shared ( Args &&... args )

Fall back to the boost version if no need for alignment.

Definition at line 62 of file make_shared.h.

◆ makeBinaryOrdering()

std::pair<KeyVector, std::vector<int> > gtsam::makeBinaryOrdering ( std::vector< Key > & input )

inline

Return the ordering as a binary tree such that all parent nodes are above their children.

This will result in a nested dissection Bayes tree after elimination.

Parameters

input The original ordering.

Returns: std::pair<KeyVector, std::vector<int>>

Definition at line 89 of file Switching.h.

◆ MakeFunctorizedFactor()

template<typename T , typename R , typename FUNC >

FunctorizedFactor<R, T> gtsam::MakeFunctorizedFactor	(	Key	key,
		const R &	z,
		const SharedNoiseModel &	model,
		const FUNC	func
	)

Helper function to create a functorized factor.

Uses function template deduction to identify return type and functor type, so template list only needs the functor argument type.

Definition at line 148 of file FunctorizedFactor.h.

◆ MakeFunctorizedFactor2()

template<typename T1 , typename T2 , typename R , typename FUNC >

FunctorizedFactor2<R, T1, T2> gtsam::MakeFunctorizedFactor2	(	Key	key1,
		Key	key2,
		const R &	z,
		const SharedNoiseModel &	model,
		const FUNC	func
	)

Helper function to create a functorized factor.

Uses function template deduction to identify return type and functor type, so template list only needs the functor argument type.

Definition at line 260 of file FunctorizedFactor.h.

◆ makeSwitchingChain()

HybridGaussianFactorGraph::shared_ptr gtsam::makeSwitchingChain	(	size_t	K,
		std::function< Key(int)>	x = `X`,
		std::function< Key(int)>	m = `M`,
		const std::string &	transitionProbabilityTable = `"0 1 1 3"`
	)

inline

Create a switching system chain. A switching system is a continuous system which depends on a discrete mode at each time step of the chain.

Parameters

K	The number of chain elements.
x	The functional to help specify the continuous key.
m	The functional to help specify the discrete key.

Returns: HybridGaussianFactorGraph::shared_ptr

Definition at line 54 of file Switching.h.

◆ markdown()

string gtsam::markdown	(	const DiscreteValues &	values,
		const KeyFormatter &	keyFormatter,
		const DiscreteValues::Names &	names
	)

Free version of markdown.

Definition at line 130 of file DiscreteValues.cpp.

◆ matlabFormat()

const Eigen::IOFormat & gtsam::matlabFormat ( )

Definition at line 139 of file Matrix.cpp.

◆ maxKey()

template<class PROBLEM >

Key gtsam::maxKey ( const PROBLEM & problem )

Find the max key in a problem. Useful to determine unique keys for additional slack variables

Definition at line 191 of file ActiveSetSolver.h.

◆ mean()

template<class CONTAINER >

Point3 gtsam::mean ( const CONTAINER & points )

mean

Definition at line 70 of file Point3.h.

◆ means() [1/2]

Point2Pair gtsam::means ( const std::vector< Point2Pair > & abPointPairs )

Calculate the two means of a set of Point2 pairs.

Definition at line 116 of file Point2.cpp.

◆ means() [2/2]

Point3Pair gtsam::means ( const std::vector< Point3Pair > & abPointPairs )

Calculate the two means of a set of Point3 pairs.

Definition at line 79 of file Point3.cpp.

◆ moveWithBounce()

std::pair<Pose2, bool> gtsam::moveWithBounce	(	const Pose2 &	cur_pose,
		double	step_size,
		const std::vector< SimWall2D >	walls,
		Sampler &	angle_drift,
		Sampler &	reflect_noise,
		const Rot2 &	bias = `Rot2()`
	)

Calculates the next pose in a trajectory constrained by walls, with noise on angular drift and reflection noise

Parameters

cur_pose	is the pose of the robot
step_size	is the size of the forward step the robot tries to take
walls	is a set of walls to use for bouncing
angle_drift	is a sampler for angle drift (dim=1)
reflect_noise	is a sampler for scatter after hitting a wall (dim=3)

Returns: the next pose for the robot NOTE: samplers cannot be const

Definition at line 125 of file SimWall2D.cpp.

◆ mrsymbol()

Key gtsam::mrsymbol	(	unsigned char	c,
		unsigned char	label,
		size_t	j
	)

inline

Create a symbol key from a character, label and index, i.e. xA5.

Definition at line 158 of file LabeledSymbol.h.

◆ mrsymbolChr()

unsigned char gtsam::mrsymbolChr ( Key key )

inline

Return the character portion of a symbol key.

Definition at line 163 of file LabeledSymbol.h.

◆ mrsymbolIndex()

size_t gtsam::mrsymbolIndex ( Key key )

inline

Return the index portion of a symbol key.

Definition at line 171 of file LabeledSymbol.h.

◆ mrsymbolLabel()

unsigned char gtsam::mrsymbolLabel ( Key key )

inline

Return the label portion of a symbol key.

Definition at line 166 of file LabeledSymbol.h.

◆ nonlinearConjugateGradient()

template<class S , class V >

std::tuple<V, int> gtsam::nonlinearConjugateGradient	(	const S &	system,
		const V &	initial,
		const NonlinearOptimizerParams &	params,
		const bool	singleIteration,
		const DirectionMethod &	directionMethod = `DirectionMethod::PolakRibiere`,
		const bool	gradientDescent = `false`
	)

Implement the nonlinear conjugate gradient method using the Polak-Ribiere formula suggested in http://en.wikipedia.org/wiki/Nonlinear_conjugate_gradient_method.

The S (system) class requires three member functions: error(state), gradient(state) and advance(state, step-size, direction). The V class denotes the state or the solution.

The last parameter is a switch between gradient-descent and conjugate gradient

Definition at line 196 of file NonlinearConjugateGradientOptimizer.h.

◆ norm2()

double gtsam::norm2	(	const Point2 &	p,
		OptionalJacobian< 1, 2 >	H
	)

Distance of the point from the origin, with Jacobian.

Definition at line 27 of file Point2.cpp.

◆ norm3()

double gtsam::norm3	(	const Point3 &	p,
		OptionalJacobian< 1, 3 >	H
	)

Distance of the point from the origin, with Jacobian.

Definition at line 41 of file Point3.cpp.

◆ normal()

Unit3_ gtsam::normal ( const OrientedPlane3_ & p )

inline

Definition at line 121 of file slam/expressions.h.

◆ normalize() [1/3]

Point3 gtsam::normalize	(	const Point3 &	p,
		OptionalJacobian< 3, 3 >	H
	)

normalize, with optional Jacobian

Definition at line 52 of file Point3.cpp.

◆ normalize() [2/3]

Point3_ gtsam::normalize ( const Point3_ & a )

inline

Definition at line 61 of file slam/expressions.h.

◆ normalize() [3/3]

static void gtsam::normalize ( Signature::Row & row )

static

Definition at line 88 of file Signature.cpp.

◆ NrUnknowns()

template<size_t d>

static size_t gtsam::NrUnknowns ( const typename ShonanAveraging< d >::Measurements & measurements )

static

Definition at line 97 of file ShonanAveraging.cpp.

◆ numericalDerivative11() [1/2]

template<class Y , class X , int N = traits<X>::dimension>

internal::FixedSizeMatrix<Y, X>::type gtsam::numericalDerivative11	(	std::function< Y(const X &)>	h,
		const X &	x,
		double	delta = `1e-5`
	)

New-style numerical derivatives using manifold_traits.

Computes numerical derivative in argument 1 of unary function

Parameters

h	unary function yielding m-vector
x	n-dimensional value at which to evaluate h
delta	increment for numerical derivative Class Y is the output argument Class X is the input argument

Template Parameters

int	N is the dimension of the X input value if variable dimension type but known at test time

Returns: m*n Jacobian computed via central differencing

Definition at line 110 of file numericalDerivative.h.

◆ numericalDerivative11() [2/2]

template<class Y , class X >

internal::FixedSizeMatrix<Y,X>::type gtsam::numericalDerivative11	(	Y(*)(const X &)	h,
		const X &	x,
		double	delta = `1e-5`
	)

use a raw C++ function pointer

Definition at line 150 of file numericalDerivative.h.

◆ numericalDerivative21() [1/2]

template<class Y , class X1 , class X2 , int N = traits<X1>::dimension>

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative21	(	const std::function< Y(const X1 &, const X2 &)> &	h,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 1 of binary function

Parameters

h	binary function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X1 input value if variable dimension type but known at test time

Definition at line 166 of file numericalDerivative.h.

◆ numericalDerivative21() [2/2]

template<class Y , class X1 , class X2 >

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative21	(	Y(*)(const X1 &, const X2 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

use a raw C++ function pointer

Definition at line 178 of file numericalDerivative.h.

◆ numericalDerivative22() [1/2]

template<class Y , class X1 , class X2 , int N = traits<X2>::dimension>

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative22	(	std::function< Y(const X1 &, const X2 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 2 of binary function

Parameters

h	binary function yielding m-vector
x1	first argument value
x2	n-dimensional second argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X2 input value if variable dimension type but known at test time

Definition at line 195 of file numericalDerivative.h.

◆ numericalDerivative22() [2/2]

template<class Y , class X1 , class X2 >

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative22	(	Y(*)(const X1 &, const X2 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

use a raw C++ function pointer

Definition at line 207 of file numericalDerivative.h.

◆ numericalDerivative31() [1/2]

template<class Y , class X1 , class X2 , class X3 , int N = traits<X1>::dimension>

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative31	(	std::function< Y(const X1 &, const X2 &, const X3 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 1 of ternary function

Parameters

h	ternary function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing All classes Y,X1,X2,X3 need dim, expmap, logmap

Template Parameters

int	N is the dimension of the X1 input value if variable dimension type but known at test time

Definition at line 226 of file numericalDerivative.h.

◆ numericalDerivative31() [2/2]

template<class Y , class X1 , class X2 , class X3 >

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative31	(	Y(*)(const X1 &, const X2 &, const X3 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		double	delta = `1e-5`
	)

Definition at line 239 of file numericalDerivative.h.

◆ numericalDerivative32() [1/2]

template<class Y , class X1 , class X2 , class X3 , int N = traits<X2>::dimension>

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative32	(	std::function< Y(const X1 &, const X2 &, const X3 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 2 of ternary function

Parameters

h	ternary function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing All classes Y,X1,X2,X3 need dim, expmap, logmap

Template Parameters

int	N is the dimension of the X2 input value if variable dimension type but known at test time

Definition at line 259 of file numericalDerivative.h.

◆ numericalDerivative32() [2/2]

template<class Y , class X1 , class X2 , class X3 >

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative32	(	Y(*)(const X1 &, const X2 &, const X3 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		double	delta = `1e-5`
	)

inline

Definition at line 272 of file numericalDerivative.h.

◆ numericalDerivative33() [1/2]

template<class Y , class X1 , class X2 , class X3 , int N = traits<X3>::dimension>

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative33	(	std::function< Y(const X1 &, const X2 &, const X3 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 3 of ternary function

Parameters

h	ternary function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing All classes Y,X1,X2,X3 need dim, expmap, logmap

Template Parameters

int	N is the dimension of the X3 input value if variable dimension type but known at test time

Definition at line 292 of file numericalDerivative.h.

◆ numericalDerivative33() [2/2]

template<class Y , class X1 , class X2 , class X3 >

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative33	(	Y(*)(const X1 &, const X2 &, const X3 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		double	delta = `1e-5`
	)

inline

Definition at line 305 of file numericalDerivative.h.

◆ numericalDerivative41() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X1>::dimension>

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative41	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 1 of 4-argument function

Parameters

h	quartic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X1 input value if variable dimension type but known at test time

Definition at line 325 of file numericalDerivative.h.

◆ numericalDerivative41() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 >

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative41	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		double	delta = `1e-5`
	)

inline

Definition at line 339 of file numericalDerivative.h.

◆ numericalDerivative42() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X2>::dimension>

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative42	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 2 of 4-argument function

Parameters

h	quartic function yielding m-vector
x1	first argument value
x2	n-dimensional second argument value
x3	third argument value
x4	fourth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X2 input value if variable dimension type but known at test time

Definition at line 359 of file numericalDerivative.h.

◆ numericalDerivative42() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 >

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative42	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		double	delta = `1e-5`
	)

inline

Definition at line 373 of file numericalDerivative.h.

◆ numericalDerivative43() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X3>::dimension>

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative43	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 3 of 4-argument function

Parameters

h	quartic function yielding m-vector
x1	first argument value
x2	second argument value
x3	n-dimensional third argument value
x4	fourth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X3 input value if variable dimension type but known at test time

Definition at line 393 of file numericalDerivative.h.

◆ numericalDerivative43() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 >

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative43	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		double	delta = `1e-5`
	)

inline

Definition at line 407 of file numericalDerivative.h.

◆ numericalDerivative44() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X4>::dimension>

internal::FixedSizeMatrix<Y,X4>::type gtsam::numericalDerivative44	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 4 of 4-argument function

Parameters

h	quartic function yielding m-vector
x1	first argument value
x2	second argument value
x3	third argument value
x4	n-dimensional fourth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X4 input value if variable dimension type but known at test time

Definition at line 427 of file numericalDerivative.h.

◆ numericalDerivative44() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 >

internal::FixedSizeMatrix<Y,X4>::type gtsam::numericalDerivative44	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		double	delta = `1e-5`
	)

inline

Definition at line 441 of file numericalDerivative.h.

◆ numericalDerivative51() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X1>::dimension>

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative51	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 1 of 5-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X1 input value if variable dimension type but known at test time

Definition at line 462 of file numericalDerivative.h.

◆ numericalDerivative51() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative51	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

inline

Definition at line 476 of file numericalDerivative.h.

◆ numericalDerivative52() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X2>::dimension>

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative52	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 2 of 5-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X2 input value if variable dimension type but known at test time

Definition at line 498 of file numericalDerivative.h.

◆ numericalDerivative52() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative52	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

inline

Definition at line 512 of file numericalDerivative.h.

◆ numericalDerivative53() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X3>::dimension>

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative53	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 3 of 5-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X3 input value if variable dimension type but known at test time

Definition at line 534 of file numericalDerivative.h.

◆ numericalDerivative53() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative53	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

inline

Definition at line 548 of file numericalDerivative.h.

◆ numericalDerivative54() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X4>::dimension>

internal::FixedSizeMatrix<Y,X4>::type gtsam::numericalDerivative54	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 4 of 5-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X4 input value if variable dimension type but known at test time

Definition at line 570 of file numericalDerivative.h.

◆ numericalDerivative54() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >

internal::FixedSizeMatrix<Y,X4>::type gtsam::numericalDerivative54	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

inline

Definition at line 584 of file numericalDerivative.h.

◆ numericalDerivative55() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , int N = traits<X5>::dimension>

internal::FixedSizeMatrix<Y,X5>::type gtsam::numericalDerivative55	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 5 of 5-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X5 input value if variable dimension type but known at test time

Definition at line 606 of file numericalDerivative.h.

◆ numericalDerivative55() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 >

internal::FixedSizeMatrix<Y,X5>::type gtsam::numericalDerivative55	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		double	delta = `1e-5`
	)

inline

Definition at line 620 of file numericalDerivative.h.

◆ numericalDerivative61() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X1>::dimension>

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative61	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 1 of 6-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
x6	sixth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X1 input value if variable dimension type but known at test time

Definition at line 643 of file numericalDerivative.h.

◆ numericalDerivative61() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative61	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

inline

Definition at line 657 of file numericalDerivative.h.

◆ numericalDerivative62() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X2>::dimension>

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative62	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 2 of 6-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
x6	sixth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X2 input value if variable dimension type but known at test time

Definition at line 680 of file numericalDerivative.h.

◆ numericalDerivative62() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative62	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

inline

Definition at line 694 of file numericalDerivative.h.

◆ numericalDerivative63() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X3>::dimension>

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative63	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 3 of 6-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
x6	sixth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X3 input value if variable dimension type but known at test time

Definition at line 717 of file numericalDerivative.h.

◆ numericalDerivative63() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative63	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

inline

Definition at line 731 of file numericalDerivative.h.

◆ numericalDerivative64() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X4>::dimension>

internal::FixedSizeMatrix<Y,X4>::type gtsam::numericalDerivative64	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 4 of 6-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
x6	sixth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X4 input value if variable dimension type but known at test time

Definition at line 754 of file numericalDerivative.h.

◆ numericalDerivative64() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >

internal::FixedSizeMatrix<Y,X4>::type gtsam::numericalDerivative64	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

inline

Definition at line 768 of file numericalDerivative.h.

◆ numericalDerivative65() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X5>::dimension>

internal::FixedSizeMatrix<Y,X5>::type gtsam::numericalDerivative65	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 5 of 6-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
x6	sixth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X5 input value if variable dimension type but known at test time

Definition at line 791 of file numericalDerivative.h.

◆ numericalDerivative65() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >

internal::FixedSizeMatrix<Y,X5>::type gtsam::numericalDerivative65	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

inline

Definition at line 805 of file numericalDerivative.h.

◆ numericalDerivative66() [1/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 , int N = traits<X6>::dimension>

internal::FixedSizeMatrix<Y, X6>::type gtsam::numericalDerivative66	(	std::function< Y(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)>	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

Compute numerical derivative in argument 6 of 6-argument function

Parameters

h	quintic function yielding m-vector
x1	n-dimensional first argument value
x2	second argument value
x3	third argument value
x4	fourth argument value
x5	fifth argument value
x6	sixth argument value
delta	increment for numerical derivative

Returns: m*n Jacobian computed via central differencing

Template Parameters

int	N is the dimension of the X6 input value if variable dimension type but known at test time

Definition at line 828 of file numericalDerivative.h.

◆ numericalDerivative66() [2/2]

template<class Y , class X1 , class X2 , class X3 , class X4 , class X5 , class X6 >

internal::FixedSizeMatrix<Y,X6>::type gtsam::numericalDerivative66	(	Y(*)(const X1 &, const X2 &, const X3 &, const X4 &, const X5 &, const X6 &)	h,
		const X1 &	x1,
		const X2 &	x2,
		const X3 &	x3,
		const X4 &	x4,
		const X5 &	x5,
		const X6 &	x6,
		double	delta = `1e-5`
	)

inline

Definition at line 843 of file numericalDerivative.h.

◆ numericalGradient()

template<class X , int N = traits<X>::dimension>

Eigen::Matrix<double, N, 1> gtsam::numericalGradient	(	std::function< double(const X &)>	h,
		const X &	x,
		double	delta = `1e-5`
	)

Numerically compute gradient of scalar function.

Returns: n-dimensional gradient computed via central differencing Class X is the input argument The class X needs to have dim, expmap, logmap int N is the dimension of the X input value if variable dimension type but known at test time

Definition at line 70 of file numericalDerivative.h.

◆ numericalHessian() [1/2]

template<class X >

internal::FixedSizeMatrix<X,X>::type gtsam::numericalHessian	(	double(*)(const X &)	f,
		const X &	x,
		double	delta = `1e-5`
	)

inline

Definition at line 874 of file numericalDerivative.h.

◆ numericalHessian() [2/2]

template<class X >

internal::FixedSizeMatrix<X,X>::type gtsam::numericalHessian	(	std::function< double(const X &)>	f,
		const X &	x,
		double	delta = `1e-5`
	)

inline

Compute numerical Hessian matrix. Requires a single-argument Lie->scalar function. This is implemented simply as the derivative of the gradient.

Parameters

f	A function taking a Lie object as input and returning a scalar
x	The center point for computing the Hessian
delta	The numerical derivative step size

Returns: n*n Hessian matrix computed via central differencing

Definition at line 861 of file numericalDerivative.h.

◆ numericalHessian211() [1/2]

template<class X1 , class X2 >

internal::FixedSizeMatrix<X1,X1>::type gtsam::numericalHessian211	(	double(*)(const X1 &, const X2 &)	f,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

inline

Definition at line 938 of file numericalDerivative.h.

◆ numericalHessian211() [2/2]

template<class X1 , class X2 >

internal::FixedSizeMatrix<X1,X1>::type gtsam::numericalHessian211	(	std::function< double(const X1 &, const X2 &)>	f,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

inline

Definition at line 920 of file numericalDerivative.h.

◆ numericalHessian212() [1/2]

template<class X1 , class X2 >

internal::FixedSizeMatrix<X1,X2>::type gtsam::numericalHessian212	(	double(*)(const X1 &, const X2 &)	f,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

inline

Definition at line 913 of file numericalDerivative.h.

◆ numericalHessian212() [2/2]

template<class X1 , class X2 >

internal::FixedSizeMatrix<X1,X2>::type gtsam::numericalHessian212	(	std::function< double(const X1 &, const X2 &)>	f,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

inline

Definition at line 901 of file numericalDerivative.h.

◆ numericalHessian222() [1/2]

template<class X1 , class X2 >

internal::FixedSizeMatrix<X2,X2>::type gtsam::numericalHessian222	(	double(*)(const X1 &, const X2 &)	f,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

inline

Definition at line 961 of file numericalDerivative.h.

◆ numericalHessian222() [2/2]

template<class X1 , class X2 >

internal::FixedSizeMatrix<X2,X2>::type gtsam::numericalHessian222	(	std::function< double(const X1 &, const X2 &)>	f,
		const X1 &	x1,
		const X2 &	x2,
		double	delta = `1e-5`
	)

inline

Definition at line 945 of file numericalDerivative.h.