traits More...

Namespaces
	dynamics

	example

	examples

	imuBias
	All bias models live in the imuBias namespace.

	inference

	initialize

	internal

	lago

	linear

	noiseModel
	All noise models live in the noiseModel namespace.

	parser

	partition

	serializationTestHelpers

	simulated3D

	so3

	symbol_shorthand

	testing

	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

class	BatchFixedLagSmoother

class	BayesNet

class	BayesTree

class	BayesTreeCliqueBase

struct	BayesTreeCliqueData

struct	BayesTreeCliqueStats

class	BayesTreeOrphanWrapper

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	BinaryAllDiff

struct	BinaryJacobianFactor

class	BinaryMeasurement

class	BinarySumExpression

class	BlockJacobiPreconditioner

struct	BlockJacobiPreconditionerParameters

struct	BoundingConstraint1

struct	BoundingConstraint2

class	BTree

class	Cal3

class	Cal3_S2

class	Cal3_S2Stereo

class	Cal3Bundler

struct	Cal3Bundler0

class	Cal3DS2

class	Cal3DS2_Base

class	Cal3Fisheye

class	Cal3Unified

class	CalibratedCamera

struct	CameraProjectionMatrix

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

struct	CGState

class	CheiralityException

class	CholeskyFailed
	Indicate Cholesky factorization failure. More...

class	ClusterTree

class	CombinedImuFactor

class	compose_key_visitor

class	ConcurrentBatchFilter

class	ConcurrentBatchSmoother

class	ConcurrentFilter

class	ConcurrentIncrementalFilter

class	ConcurrentIncrementalSmoother

class	ConcurrentMap

class	ConcurrentSmoother

class	Conditional

class	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	CRefCallAddCopy

class	CRefCallPushBack

class	CSP

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

class	DecisionTree

class	DecisionTreeFactor

class	DeltaFactor

class	DeltaFactorBase

struct	DeltaImpl

struct	DGroundConstraint

struct	DHeightPrior

class	DirectProduct

class	DirectSum

class	DiscreteBayesNet

class	DiscreteBayesTree

class	DiscreteBayesTreeClique

class	DiscreteConditional

class	DiscreteEliminationTree

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	DiscreteMarginals

class	DoglegOptimizer

struct	DoglegOptimizerImpl

class	DoglegParams

class	Domain

struct	DRollPrior

class	DSF

class	DSFBase

class	DSFMap

class	DSFVector

struct	Dummy

class	DummyFactor

class	DummyPreconditioner

struct	DummyPreconditionerParameters

class	DynamicValuesMismatched

class	EliminatableClusterTree

class	EliminateableFactorGraph

struct	EliminationData

struct	EliminationTraits

struct	EliminationTraits< DiscreteFactorGraph >

struct	EliminationTraits< GaussianFactorGraph >

struct	EliminationTraits< SymbolicFactorGraph >

class	EliminationTree

class	EqualityFactorGraph

struct	equals

struct	equals_star

struct	equalsVector

class	EquivInertialNavFactor_GlobalVel

class	EquivInertialNavFactor_GlobalVel_NoBias

class	Errors

class	EssentialMatrix

class	EssentialMatrixConstraint

class	EssentialMatrixFactor

class	EssentialMatrixFactor2

class	EssentialMatrixFactor3

class	Event

class	Expression

class	ExpressionFactor

class	ExpressionFactorGraph

class	ExpressionFactorN

class	ExtendedKalmanFilter

class	Factor

class	FactorGraph

class	FastList

class	FastMap

class	FastSet

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

class	FixedLagSmoother

class	FixedVector

class	FrobeniusBetweenFactor

class	FrobeniusFactor

class	FrobeniusPrior

class	FullIMUFactor

class	FunctorizedFactor

class	FunctorizedFactor2

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...

class	IMUFactor

class	ImuFactor

class	ImuFactor2

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

class	InconsistentEliminationRequested

class	IncrementalFixedLagSmoother

class	IndeterminantLinearSystemException

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

struct	LieMatrix

struct	LieScalar

struct	LieVector

class	Line3

class	LinearContainerFactor

class	LinearCost

class	LinearEquality

class	LinearInequality

class	LinearizedGaussianFactor

class	LinearizedHessianFactor

class	LinearizedJacobianFactor

class	ListOfOneContainer

class	LocalOrientedPlane3Factor

struct	LP

class	LPInitSolver

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

class	MagFactor

class	MagFactor1

class	MagFactor2

class	MagFactor3

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	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

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	NoiseModelFactor1

class	NoiseModelFactor2

class	NoiseModelFactor3

class	NoiseModelFactor4

class	NoiseModelFactor5

class	NoiseModelFactor6

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	Potentials

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

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< 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	RefCallPushBack

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...

class	Rot2

class	Rot3

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
	Define the structure for SfM data. More...

struct	SfmTrack
	Define the structure for the 3D points. More...

class	SGraph

class	ShonanAveraging

class	ShonanAveraging2

class	ShonanAveraging3

struct	ShonanAveragingParameters
	Parameters governing optimization etc. More...

class	ShonanFactor

class	ShonanGaugeFactor

class	Signature

class	Similarity3

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 Cameras argument, which should behave like PinholeCamera, and the value of a point, which is kept in the base class. More...

class	SmartProjectionFactor

struct	SmartProjectionParams

class	SmartProjectionPoseFactor

class	SmartRangeFactor

class	SmartStereoProjectionFactor

class	SmartStereoProjectionPoseFactor

class	SO

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

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	TangentPreintegration

class	TbbOpenMPMixedScope

struct	Testable

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< 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< BinaryJacobianFactor< M, N1, N2 > >

struct	traits< Cal3_S2 >

struct	traits< Cal3_S2Stereo >

struct	traits< Cal3Bundler >

struct	traits< Cal3Bundler0 >

struct	traits< Cal3DS2 >

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 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 Similarity3 >

struct	traits< const SO3 >

struct	traits< const SO4 >

struct	traits< const SO< N > >

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< DecisionTreeFactor >

struct	traits< Dih6 >

struct	traits< DirectProduct< G, H > >

struct	traits< DirectSum< G, H > >

struct	traits< DiscreteBayesNet >

struct	traits< DiscreteConditional >

struct	traits< DiscreteFactor >

struct	traits< DiscreteFactor::Values >

struct	traits< DiscreteFactorGraph >
	traits More...

struct	traits< double >
	double More...

struct	traits< DT >

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

struct	traits< Eigen::Matrix< double, M, N, 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< 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< 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< 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< LieMatrix >

struct	traits< LieScalar >

struct	traits< LieVector >

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< Potentials >

struct	traits< Potentials::ADT >

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< 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 >
	traits More...

struct	traits< Similarity3 >

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< SmartStereoProjectionFactor >
	traits More...

struct	traits< SmartStereoProjectionPoseFactor >
	traits More...

struct	traits< SO3 >

struct	traits< SO4 >

struct	traits< SO< N > >

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< 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	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...

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	VectorValues

class	VelocityConstraint

class	VelocityConstraint3

struct	VelocityPrior

class	VerticalBlockMatrix

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 = std::vector< BetweenFactor< Pose2 >::shared_ptr >

using	BetweenFactorPose3s = std::vector< BetweenFactor< Pose3 >::shared_ptr >

using	BinaryMeasurementsUnit3 = std::vector< BinaryMeasurement< Unit3 >>

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 >>

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

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

typedef DirectProduct< S2, S3 >	Dih6

typedef std::pair< Key, size_t >	DiscreteKey

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...

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	GraphAndValues = std::pair< NonlinearFactorGraph::shared_ptr, Values::shared_ptr >

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

typedef std::vector< IndexPair >	IndexPairVector

typedef FastMap< char, Vector >	ISAM2ThresholdMap

typedef ISAM2ThresholdMap::value_type	ISAM2ThresholdMapValue

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

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

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

typedef FastMap< Key, int >	KeyGroupMap

typedef FastList< Key >	KeyList

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

typedef std::map< Key, Rot3 >	KeyRotMap

typedef FastSet< Key >	KeySet

typedef FastVector< Key >	KeyVector
	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

typedef Expression< NavState >	NavState_

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

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

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

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

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

typedef Vector2	Point2

typedef Expression< Point2 >	Point2_

typedef std::pair< Point2, Point2 >	Point2Pair

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

typedef Vector3	Point3

typedef Expression< Point3 >	Point3_

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

using	Point3Pairs = std::vector< Point3Pair >

typedef Expression< Pose2 >	Pose2_

typedef Expression< Pose3 >	Pose3_

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

using	Pose3Pairs = std::vector< std::pair< Pose3, Pose3 > >

typedef std::vector< Pose3 >	Pose3Vector

typedef ManifoldPreintegration	PreintegrationType

using	QPSolver = ActiveSetSolver< QP, QPPolicy, QPInitSolver >

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

typedef Expression< Rot2 >	Rot2_

typedef Expression< Rot3 >	Rot3_

typedef Eigen::RowVectorXd	RowVector

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...

typedef noiseModel::Constrained::shared_ptr	SharedConstrained

typedef noiseModel::Diagonal::shared_ptr	SharedDiagonal

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

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...

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

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 &)

boost::optional< Pose2 >	align (const vector< Point2Pair > &pairs)

GTSAM_EXPORT boost::optional< Pose2 >	align (const std::vector< Point2Pair > &pairs)

boost::optional< Pose3 >	align (const Point3Pairs &baPointPairs)

template<typename Y , typename L >
DecisionTree< L, Y >	apply (const DecisionTree< L, Y > &f, const typename DecisionTree< L, Y >::Unary &op)

template<typename Y , typename L >
DecisionTree< L, Y >	apply (const DecisionTree< L, Y > &f, const DecisionTree< L, Y > &g, const typename DecisionTree< L, Y >::Binary &op)

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 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::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 Key &expected, const Key &actual, double tol=0.0)

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

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

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

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

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

template<class V >
bool	assert_equal (const std::vector< V > &expected, const std::vector< 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_equal (const SubVector &expected, const SubVector &actual, double tol)

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

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

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

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

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

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)

template<class V1 , class V2 >
void	axpy (double alpha, const V1 &x, V2 &y)

void	axpy (double alpha, const Vector &x, SubVector y)

template<>
GTSAM_EXPORT void	axpy< Errors, Errors > (double alpha, const Errors &x, Errors &y)

template<>
void	axpy< Errors, Errors > (double alpha, const Errors &x, Errors &y)

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)

	BOOST_CONCEPT_ASSERT ((boost::RandomAccessRangeConcept< ListOfOneContainer< int > >))

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

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

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

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

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=boost::none, OptionalJacobian< 2, 2 > Dp=boost::none)

template<typename L >
std::vector< Assignment< L > >	cartesianProduct (const std::vector< std::pair< L, size_t > > &keys)
	Get Cartesian product consisting all possible configurations. 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)

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

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

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)

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

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

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

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

Matrix	collect (size_t nrMatrices,...)

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

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 >
boost::shared_ptr< Values >	composePoses (const G &graph, const PredecessorMap< KEY > &tree, const POSE &rootPose)

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

Vector	concatVectors (size_t nrVectors,...)

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

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

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

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

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

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

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

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

static GaussianFactorGraph::shared_ptr	convertToJacobianFactors (const GaussianFactorGraph &gfg)

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

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

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

string	createRewrittenFileName (const string &name)

boost::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=boost::none, OptionalJacobian< 3, 3 > H_q=boost::none)
	cross product More...

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)

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)

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

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

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

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

double	dot (const Errors &a, const Errors &b)

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

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

std::pair< boost::shared_ptr< GaussianConditional >, boost::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)

std::pair< boost::shared_ptr< GaussianConditional >, boost::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< boost::shared_ptr< SymbolicConditional >, boost::shared_ptr< SymbolicFactor > >	EliminateSymbolic (const SymbolicFactorGraph &factors, const Ordering &keys)

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

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

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

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

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 Vector &vec1, const Vector &vec2, double tol)

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

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

Matrix	expm (const Matrix &A, size_t K)

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

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

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

string	findExampleDataFile (const string &name)

template<class T , typename = typename std::enable_if< std::is_same<gtsam::Rot3, T>::value >::type>
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)

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)

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 Rot3 &R, double tx, double ty, double tz)
	This function converts a GTSAM camera pose to an openGL camera pose. More...

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

	GTSAM_CONCEPT_POSE_INST (Pose2)

	GTSAM_CONCEPT_POSE_INST (Pose3)

	GTSAM_MAKE_MATRIX_DEFS (1)

	GTSAM_MAKE_MATRIX_DEFS (2)

	GTSAM_MAKE_MATRIX_DEFS (3)

	GTSAM_MAKE_MATRIX_DEFS (4)

	GTSAM_MAKE_MATRIX_DEFS (5)

	GTSAM_MAKE_MATRIX_DEFS (6)

	GTSAM_MAKE_MATRIX_DEFS (7)

	GTSAM_MAKE_MATRIX_DEFS (8)

	GTSAM_MAKE_MATRIX_DEFS (9)

	GTSAM_MAKE_VECTOR_DEFS (4)

	GTSAM_MAKE_VECTOR_DEFS (5)

	GTSAM_MAKE_VECTOR_DEFS (6)

	GTSAM_MAKE_VECTOR_DEFS (7)

	GTSAM_MAKE_VECTOR_DEFS (8)

	GTSAM_MAKE_VECTOR_DEFS (9)

	GTSAM_MAKE_VECTOR_DEFS (10)

	GTSAM_MAKE_VECTOR_DEFS (11)

	GTSAM_MAKE_VECTOR_DEFS (12)

bool	guardedIsDebug (const std::string &s)

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

bool	hasConstraints (const GaussianFactorGraph &factors)

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)

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)

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)

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 boost::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)

template<typename T >
ListOfOneContainer< T >	ListOfOne (const T &element)

Matrix	LLt (const Matrix &A)

GTSAM_EXPORT GraphAndValues	load2D (std::pair< std::string, SharedNoiseModel > dataset, size_t maxIndex=0, bool addNoise=false, bool smart=true, NoiseFormat noiseFormat=NoiseFormatAUTO, KernelFunctionType kernelFunctionType=KernelFunctionTypeNONE)

GTSAM_EXPORT GraphAndValues	load2D (const std::string &filename, SharedNoiseModel model=SharedNoiseModel(), size_t maxIndex=0, bool addNoise=false, bool smart=true, NoiseFormat noiseFormat=NoiseFormatAUTO, KernelFunctionType kernelFunctionType=KernelFunctionTypeNONE)

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

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

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

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

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

GraphAndValues	load3D (const string &filename)
	Load TORO 3D Graph. 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, boost::shared_ptr< T > >	make_shared (Args &&...args)

template<typename T , typename... Args>
gtsam::enable_if_t<!needs_eigen_aligned_allocator< T >::value, boost::shared_ptr< T > >	make_shared (Args &&...args)
	Fall back to the boost version if no need for alignment. 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)

const Eigen::IOFormat &	matlabFormat ()

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

template<class CONTAINER >
Point3	mean (const CONTAINER &points)
	mean 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)

unsigned char	mrsymbolChr (Key key)

size_t	mrsymbolIndex (Key key)

unsigned char	mrsymbolLabel (Key key)

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

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

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

Point3	normalize (const Point3 &p, OptionalJacobian< 3, 3 > H=boost::none)
	normalize, with optional Jacobian More...

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 (boost::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 boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::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 (boost::function< double(const X &)> f, const X &x, double delta=1e-5)

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

template<class X1 , class X2 >
internal::FixedSizeMatrix< X1, X1 >::type	numericalHessian211 (boost::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, 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, X2 >::type	numericalHessian212 (boost::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< X2, X2 >::type	numericalHessian222 (boost::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 , class X3 >
internal::FixedSizeMatrix< X1, X1 >::type	numericalHessian311 (boost::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, 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, X2 >::type	numericalHessian312 (boost::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, X3 >::type	numericalHessian313 (boost::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< X2, X2 >::type	numericalHessian322 (boost::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, X3 >::type	numericalHessian323 (boost::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< X3, X3 >::type	numericalHessian333 (boost::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)

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)

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

boost::optional< IndexedEdge >	parseEdge (istream &is, const 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<>
std::vector< BetweenFactor< Pose2 >::shared_ptr >	parseFactors< Pose2 > (const std::string &filename, const noiseModel::Diagonal::shared_ptr &model, size_t maxIndex)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static Vector	perturb (const Vector &initialVector)

Point3_	position (const NavState_ &X)

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 >
boost::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 &a, const std::string &s="Error")

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

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

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

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

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 Errors &a, const string &s)

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

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	PrintKey (Key key, const string &s, const KeyFormatter &keyFormatter)
	Utility function to print one key with optional prefix. More...

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	PrintKeyList (const KeyList &keys, const string &s, const KeyFormatter &keyFormatter)
	Utility function to print sets of keys 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	PrintKeySet (const KeySet &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	PrintKeyVector (const KeyVector &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...

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)

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

GTSAM_EXPORT bool	readBAL (const std::string &filename, SfmData &data)
	This function parses a "Bundle Adjustment in the Large" (BAL) file and stores the data into a SfmData structure. More...

GTSAM_EXPORT 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...

bool	readBAL (const string &filename, SfmData &data)
	This function parses a "Bundle Adjustment in the Large" (BAL) file and stores the data into a SfmData structure. More...

SfmData	readBal (const 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...

GTSAM_EXPORT bool	readBundler (const std::string &filename, SfmData &data)
	This function parses a bundler output file and stores the data into a SfmData structure. More...

bool	readBundler (const string &filename, SfmData &data)
	This function parses a bundler output file and stores the data into a SfmData structure. More...

GTSAM_EXPORT 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...

GraphAndValues	readG2o (const string &g2oFile, const bool is3D, KernelFunctionType kernelFunctionType)
	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)

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

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

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	save2D (const NonlinearFactorGraph &graph, const Values &config, const noiseModel::Diagonal::shared_ptr model, const std::string &filename)

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

void	scal (double alpha, Vector &x)

static Scatter	scatterFromValues (const Values &values)

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

template<class Archive >
void	serialize (Archive &ar, SO4 &Q, const unsigned int)

template<class Archive >
void	serialize (Archive &ar, SO3 &R, const unsigned int)

template<class Archive >
void	serialize (Archive &ar, SOn &Q, const unsigned int file_version)

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)

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

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

template<typename Container >
static vector< size_t >	sort_idx (const Container &src)

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

SparseEigen	sparseJacobianEigen (const GaussianFactorGraph &gfg)

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::shared_ptr, GaussianFactorGraph::shared_ptr >	splitFactorGraph (const GaussianFactorGraph &factorGraph, const Subgraph &subgraph)

Matrix	stack (size_t nrMatrices,...)

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

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

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

VectorValues	steepestDescent (const GaussianFactorGraph &fg, const VectorValues &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)

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, InfiniteLoopSingleVar)

	TEST (LPInitSolver, InfiniteLoopMultiVar)

	TEST (LPInitSolver, Initialization)

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)

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)

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, boost::optional< Matrix & > Dtrans, boost::optional< Matrix & > Dglobal)

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

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

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

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

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

Point3	triangulateDLT (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 Point2Vector &measurements, double rank_tol)

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

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

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

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

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

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 CALIBRATION >
std::pair< NonlinearFactorGraph, Values >	triangulationGraph (const std::vector< Pose3 > &poses, boost::shared_ptr< CALIBRATION > sharedCal, const Point2Vector &measurements, Key landmarkKey, const Point3 &initialEstimate)

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

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

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

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

static Vector9	vec3 (const Matrix3 &R)

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

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

Matrix	vector_scale (const Matrix &A, const Vector &v, 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< boost::tuple< Vector, double, double > >	weighted_eliminate (Matrix &A, Vector &b, const Vector &sigmas)

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

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

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

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

GTSAM_EXPORT bool	writeBALfromValues (const std::string &filename, const SfmData &data, 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...

bool	writeBALfromValues (const string &filename, const SfmData &data, 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...

GTSAM_EXPORT 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...

void	writeG2o (const NonlinearFactorGraph &graph, const Values &estimate, const 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)

Standard serialization
Serialization in default compressed format
template<class T >
void	serializeToStream (const T &input, std::ostream &out_archive_stream)

template<class T >
void	deserializeFromStream (std::istream &in_archive_stream, T &output)
	deserializes from a stream More...

template<class T >
std::string	serializeToString (const T &input)
	serializes to a string More...

template<class T >
void	deserializeFromString (const std::string &serialized, T &output)
	deserializes from a string More...

template<class T >
bool	serializeToFile (const T &input, const std::string &filename)
	serializes to a file More...

template<class T >
bool	deserializeFromFile (const std::string &filename, T &output)
	deserializes from a file More...

template<class T >
std::string	serialize (const T &input)
	serializes to a string More...

template<class T >
void	deserialize (const std::string &serialized, T &output)
	deserializes from a string More...

XML Serialization
Serialization to XML format with named structures
template<class T >
void	serializeToXMLStream (const T &input, std::ostream &out_archive_stream, const std::string &name="data")

template<class T >
void	deserializeFromXMLStream (std::istream &in_archive_stream, T &output, const std::string &name="data")
	deserializes from a stream in XML More...

template<class T >
std::string	serializeToXMLString (const T &input, const std::string &name="data")
	serializes to a string in XML More...

template<class T >
void	deserializeFromXMLString (const std::string &serialized, T &output, const std::string &name="data")
	deserializes from a string in XML More...

template<class T >
bool	serializeToXMLFile (const T &input, const std::string &filename, const std::string &name="data")
	serializes to an XML file More...

template<class T >
bool	deserializeFromXMLFile (const std::string &filename, T &output, const std::string &name="data")
	deserializes from an XML file More...

template<class T >
std::string	serializeXML (const T &input, const std::string &name="data")
	serializes to a string in XML More...

template<class T >
void	deserializeXML (const std::string &serialized, T &output, const std::string &name="data")
	deserializes from a string in XML More...

Binary Serialization
Serialization to binary format with named structures
template<class T >
void	serializeToBinaryStream (const T &input, std::ostream &out_archive_stream, const std::string &name="data")

template<class T >
void	deserializeFromBinaryStream (std::istream &in_archive_stream, T &output, const std::string &name="data")
	deserializes from a stream in binary More...

template<class T >
std::string	serializeToBinaryString (const T &input, const std::string &name="data")
	serializes to a string in binary More...

template<class T >
void	deserializeFromBinaryString (const std::string &serialized, T &output, const std::string &name="data")
	deserializes from a string in binary More...

template<class T >
bool	serializeToBinaryFile (const T &input, const std::string &filename, const std::string &name="data")
	serializes to a binary file More...

template<class T >
bool	deserializeFromBinaryFile (const std::string &filename, T &output, const std::string &name="data")
	deserializes from a binary file More...

template<class T >
std::string	serializeBinary (const T &input, const std::string &name="data")
	serializes to a string in binary More...

template<class T >
void	deserializeBinary (const std::string &serialized, T &output, const std::string &name="data")
	deserializes from a string in binary More...

utility functions
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 std::map< Key, size_t > &dimensions)
	Create VectorValues from a Vector. More...

Variables
const G &	b

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

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

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

static const KeyFormatter	DefaultKeyFormatter = &_defaultKeyFormatter

static size_t	gDummyCount = 0

static const size_t	indexBits = keyBits - chrBits

static const Key	indexMask = ~chrMask

static double	intNoiseVar = 0.0000001

static const size_t	keyBits = sizeof(Key) * 8

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...

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.))

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

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 boost::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> >

triangulationFactor.h

Date: March 2, 2014

Author: Frank Dellaert

Typedef Documentation

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

Definition at line 408 of file QPSParser.cpp.

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

Definition at line 442 of file dataset.cpp.

using gtsam::BetweenFactorPose2s = typedef std::vector<BetweenFactor<Pose2>::shared_ptr>

Definition at line 494 of file dataset.h.

using gtsam::BetweenFactorPose3s = typedef std::vector<BetweenFactor<Pose3>::shared_ptr>

Definition at line 500 of file dataset.h.

using gtsam::BinaryMeasurementsUnit3 = typedef std::vector<BinaryMeasurement<Unit3>>

Definition at line 506 of file dataset.h.

typedef Expression<Cal3_S2> gtsam::Cal3_S2_

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

typedef Expression<Cal3Bundler> gtsam::Cal3Bundler_

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

typedef PinholeCamera<Cal3Bundler0> gtsam::Camera

Definition at line 55 of file testAdaptAutoDiff.cpp.

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

Definition at line 501 of file triangulation.h.

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

Definition at line 500 of file triangulation.h.

typedef ConcurrentBatchFilter::Result gtsam::ConcurrentBatchFilterResult

Typedef for Matlab wrapping.

Definition at line 254 of file ConcurrentBatchFilter.h.

typedef ConcurrentBatchSmoother::Result gtsam::ConcurrentBatchSmootherResult

Typedef for Matlab wrapping.

Definition at line 205 of file ConcurrentBatchSmoother.h.

typedef ConcurrentIncrementalFilter::Result gtsam::ConcurrentIncrementalFilterResult

Typedef for Matlab wrapping.

Definition at line 199 of file ConcurrentIncrementalFilter.h.

typedef ConcurrentIncrementalSmoother::Result gtsam::ConcurrentIncrementalSmootherResult

Typedef for Matlab wrapping.

Definition at line 169 of file ConcurrentIncrementalSmoother.h.

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

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

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

Definition at line 65 of file Vector.h.

typedef ptrdiff_t gtsam::DenseIndex

The index type for Eigen objects.

Definition at line 67 of file types.h.

typedef DirectProduct<S2, S3> gtsam::Dih6

Definition at line 107 of file testGroup.cpp.

typedef std::pair<Key,size_t> gtsam::DiscreteKey

Key type for discrete conditionals Includes name and cardinality

Definition at line 34 of file DiscreteKey.h.

typedef Expression<double> gtsam::Double_

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

typedef DSF<int> gtsam::DSFInt

Definition at line 210 of file DSF.h.

typedef DSFMap<IndexPair> gtsam::DSFMapIndexPair

Definition at line 131 of file DSFMap.h.

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

Definition at line 356 of file SOn.h.

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 31 of file make_shared.h.

typedef std::uint64_t gtsam::FactorIndex

Integer nonlinear factor index type.

Definition at line 64 of file types.h.

typedef FastSet<FactorIndex> gtsam::FactorIndexSet

Definition at line 33 of file Factor.h.

typedef FastVector< FactorIndex > gtsam::FactorIndices

Define collection types:

Define collection type:

Definition at line 32 of file Factor.h.

template<typename T >

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

Definition at line 34 of file FastVector.h.

typedef FixedLagSmoother::KeyTimestampMap gtsam::FixedLagSmootherKeyTimestampMap

Typedef for matlab wrapping.

Definition at line 134 of file FixedLagSmoother.h.

typedef FixedLagSmootherKeyTimestampMap::value_type gtsam::FixedLagSmootherKeyTimestampMapValue

Definition at line 135 of file FixedLagSmoother.h.

typedef FixedLagSmoother::Result gtsam::FixedLagSmootherResult

Definition at line 136 of file FixedLagSmoother.h.

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.

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

Definition at line 113 of file dataset.h.

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

Definition at line 112 of file dataset.h.

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

Return type for auxiliary functions.

Definition at line 111 of file dataset.h.

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

Definition at line 126 of file DSFMap.h.

typedef std::map<IndexPair, IndexPairSet> gtsam::IndexPairSetMap

Definition at line 130 of file DSFMap.h.

typedef std::vector<IndexPair> gtsam::IndexPairVector

Definition at line 125 of file DSFMap.h.

typedef FastMap<char, Vector> gtsam::ISAM2ThresholdMap

Definition at line 133 of file ISAM2Params.h.

typedef ISAM2ThresholdMap::value_type gtsam::ISAM2ThresholdMapValue

Definition at line 134 of file ISAM2Params.h.

typedef std::uint64_t gtsam::Key

Integer nonlinear key type.

Definition at line 61 of file types.h.

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

Mapping between variable's key and its corresponding dimensionality.

Definition at line 32 of file LP.h.

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

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

Definition at line 35 of file Key.h.

typedef FastMap<Key, int> gtsam::KeyGroupMap

Definition at line 91 of file Key.h.

typedef FastList<Key> gtsam::KeyList

Definition at line 89 of file Key.h.

typedef std::map<std::pair<Key, Key>, double> gtsam::KeyPairDoubleMap

Definition at line 99 of file MFAS.h.

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

Definition at line 35 of file InitializePose3.h.

typedef FastSet<Key> gtsam::KeySet

Definition at line 90 of file Key.h.

typedef FastVector<Key> gtsam::KeyVector

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

Definition at line 86 of file Key.h.

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

Definition at line 34 of file InitializePose3.h.

typedef Expression<Line3> gtsam::Line3_

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

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

Definition at line 77 of file LPSolver.h.

typedef Eigen::MatrixXd gtsam::Matrix

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

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

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

typedef Expression<NavState> gtsam::NavState_

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

template<typename T >

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

Definition at line 119 of file dataset.cpp.

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 32 of file SimpleCamera.h.

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

Definition at line 33 of file SimpleCamera.h.

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

Definition at line 34 of file SimpleCamera.h.

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

Definition at line 35 of file SimpleCamera.h.

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 27 of file Point2.h.

typedef Expression<Point2> gtsam::Point2_

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

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

Calculate pose between a vector of 2D point correspondences (p,q) where q = Pose2::transformFrom(p) = t + R*p

Definition at line 38 of file Point2.h.

typedef std::vector<Point2, Eigen::aligned_allocator<Point2> > gtsam::Point2Vector

Definition at line 42 of file Point2.h.

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 35 of file Point3.h.

typedef Expression<Point3> gtsam::Point3_

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

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

Definition at line 38 of file Point3.h.

typedef vector< Point3Pair > gtsam::Point3Pairs

Definition at line 41 of file Point3.h.

typedef Expression<Pose2> gtsam::Pose2_

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

typedef Expression<Pose3> gtsam::Pose3_

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

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

Definition at line 391 of file Pose3.h.

using gtsam::Pose3Pairs = typedef std::vector<std::pair<Pose3, Pose3> >

Definition at line 392 of file Pose3.h.

typedef std::vector<Pose3> gtsam::Pose3Vector

Definition at line 395 of file Pose3.h.

typedef ManifoldPreintegration gtsam::PreintegrationType

Definition at line 37 of file CombinedImuFactor.h.

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

Definition at line 46 of file QPSolver.h.

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

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

typedef Expression<Rot2> gtsam::Rot2_

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

typedef Expression<Rot3> gtsam::Rot3_

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

typedef Eigen::RowVectorXd gtsam::RowVector

Definition at line 25 of file LinearCost.h.

typedef PinholeCamera<Cal3Bundler> gtsam::SfmCamera

Define the structure for the camera poses.

Definition at line 323 of file dataset.h.

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

A measurement with its camera index.

Definition at line 214 of file dataset.h.

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

Definition at line 737 of file NoiseModel.h.

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

Definition at line 736 of file NoiseModel.h.

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

Definition at line 735 of file NoiseModel.h.

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

Definition at line 738 of file NoiseModel.h.

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

Note, deliberately not in noiseModel namespace. Deprecated. Only for compatibility with previous version.

Definition at line 734 of file NoiseModel.h.

using gtsam::ShonanAveragingParameters2 = typedef ShonanAveragingParameters<2>

Definition at line 104 of file ShonanAveraging.h.

using gtsam::ShonanAveragingParameters3 = typedef ShonanAveragingParameters<3>

Definition at line 105 of file ShonanAveraging.h.

using gtsam::ShonanFactor2 = typedef ShonanFactor<2>

Definition at line 88 of file ShonanFactor.h.

using gtsam::ShonanFactor3 = typedef ShonanFactor<3>

Definition at line 89 of file ShonanFactor.h.

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

Sift index for SfmTrack.

Definition at line 217 of file dataset.h.

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

Definition at line 131 of file SimPolygon2D.h.

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

Definition at line 69 of file SimWall2D.h.

typedef SmartProjectionParams gtsam::SmartStereoProjectionParams

Definition at line 42 of file SmartStereoProjectionFactor.h.

using gtsam::SO3 = typedef SO<3>

Definition at line 34 of file SO3.h.

using gtsam::SO4 = typedef SO<4>

Definition at line 34 of file SO4.h.

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

Definition at line 335 of file SOn.h.

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

Definition at line 26 of file AcceleratedPowerMethod.h.

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.

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

Definition at line 103 of file GaussianFactorGraph.cpp.

typedef internal::NonlinearOptimizerState gtsam::State

Definition at line 62 of file DoglegOptimizer.cpp.

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

Definition at line 162 of file StereoPoint2.h.

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

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

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

Definition at line 64 of file Vector.h.

typedef NonlinearOptimizerParams gtsam::SuccessiveLinearizationParams

Definition at line 193 of file NonlinearOptimizerParams.h.

typedef Expression<Unit3> gtsam::Unit3_

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

typedef Eigen::VectorXd gtsam::Vector

Definition at line 38 of file Vector.h.

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

Definition at line 41 of file Vector.h.

typedef Expression<Vector1> gtsam::Vector1_

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

typedef Eigen::Vector2d gtsam::Vector2

Definition at line 42 of file Vector.h.

typedef Expression<Vector2> gtsam::Vector2_

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

typedef Eigen::Vector3d gtsam::Vector3

Definition at line 43 of file Vector.h.

typedef Expression<Vector3> gtsam::Vector3_

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

typedef Expression<Vector4> gtsam::Vector4_

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

typedef Expression<Vector5> gtsam::Vector5_

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

typedef Expression<Vector6> gtsam::Vector6_

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

typedef Expression<Vector7> gtsam::Vector7_

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

typedef Expression<Vector8> gtsam::Vector8_

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

typedef Expression<Vector9> gtsam::Vector9_

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

typedef Vector3 gtsam::Velocity3

Velocity is currently typedef'd to Vector3.

Syntactic sugar to clarify components.

Definition at line 28 of file NavState.h.

typedef Expression<Velocity3> gtsam::Velocity3_

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

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 238 of file types.h.

Enumeration Type Documentation

enum gtsam::DegeneracyMode

How to manage degeneracy.

Enumerator
IGNORE_DEGENERACY
ZERO_ON_DEGENERACY
HANDLE_INFINITY

Definition at line 35 of file SmartFactorParams.h.

enum gtsam::GncLossType

Choice of robust loss function for GNC.

Enumerator
GM
TLS

Definition at line 36 of file GncParams.h.

enum gtsam::KernelFunctionType

Robust kernel type to wrap around quadratic noise model.

Enumerator
KernelFunctionTypeNONE
KernelFunctionTypeHUBER
KernelFunctionTypeTUKEY

Definition at line 74 of file dataset.h.

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.

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

GTSAM_EXPORT std::string gtsam::_defaultKeyFormatter ( Key key )

Definition at line 31 of file Key.cpp.

def gtsam._init ( )

private

This function is to add shims for the long-gone Point2 and Point3 types

Definition at line 6 of file python/gtsam/__init__.py.

GTSAM_EXPORT std::string gtsam::_multirobotKeyFormatter ( Key key )

Definition at line 45 of file Key.cpp.

template<typename T >

static bool gtsam::_truePredicate ( const T & )

static

Definition at line 52 of file Values.h.

boost::optional<Pose2> gtsam::align ( const vector< Point2Pair > & pairs )

Definition at line 314 of file Pose2.cpp.

GTSAM_EXPORT boost::optional<Pose2> gtsam::align ( const std::vector< Point2Pair > & pairs )

Definition at line 314 of file Pose2.cpp.

boost::optional<Pose3> gtsam::align ( const Point3Pairs & baPointPairs )

Definition at line 410 of file Pose3.cpp.

template<typename Y , typename L >

DecisionTree<L, Y> gtsam::apply	(	const DecisionTree< L, Y > &	f,
		const typename DecisionTree< L, Y >::Unary &	op
	)

free versions of apply

Definition at line 216 of file DecisionTree.h.

template<typename Y , typename L >

DecisionTree<L, Y> gtsam::apply	(	const DecisionTree< L, Y > &	f,
		const DecisionTree< L, Y > &	g,
		const typename DecisionTree< L, Y >::Binary &	op
	)

Definition at line 222 of file DecisionTree.h.

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 117 of file TestableAssertions.h.

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 155 of file TestableAssertions.h.

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 193 of file TestableAssertions.h.

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 233 of file TestableAssertions.h.

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 264 of file TestableAssertions.h.

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 302 of file TestableAssertions.h.

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

inline

Equals testing for basic types

Definition at line 34 of file TestableAssertions.h.

GTSAM_EXPORT bool gtsam::assert_equal	(	const Matrix &	A,
		const Matrix &	B,
		double	tol = `1e-9`
	)

equals with an tolerance, prints out message if unequal

Same, prints if error

Parameters

vec1	Vector
vec2	Vector
tol	1e-9

Returns: bool

Definition at line 42 of file Matrix.cpp.

template<class V >

bool gtsam::assert_equal	(	const boost::optional< V > &	expected,
		const boost::optional< V > &	actual,
		double	tol = `1e-9`
	)

Comparisons for boost.optional objects that checks whether objects exist before comparing their values. First version allows for both to be boost::none, but the second, with expected given rather than optional

Concept requirement: V is testable

Definition at line 50 of file TestableAssertions.h.

template<class V >

bool gtsam::assert_equal	(	const V &	expected,
		const boost::optional< V > &	actual,
		double	tol = `1e-9`
	)

Definition at line 66 of file TestableAssertions.h.

GTSAM_EXPORT 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 71 of file Matrix.cpp.

template<class V >

bool gtsam::assert_equal	(	const V &	expected,
		const boost::optional< const V & > &	actual,
		double	tol = `1e-9`
	)

Definition at line 75 of file TestableAssertions.h.

template<class V >

bool gtsam::assert_equal	(	const std::vector< V > &	expected,
		const std::vector< V > &	actual,
		double	tol = `1e-9`
	)

Version of assert_equals to work with vectors

Deprecated:: : use container equals instead

Definition at line 88 of file TestableAssertions.h.

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 97 of file Testable.h.

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 145 of file Vector.cpp.

GTSAM_EXPORT 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 163 of file Vector.cpp.

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

Definition at line 172 of file Vector.cpp.

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

inline

Compare strings for unit tests

Definition at line 331 of file TestableAssertions.h.

GTSAM_EXPORT bool gtsam::assert_inequal	(	const Matrix &	A,
		const Matrix &	B,
		double	tol = `1e-9`
	)

inequals with an tolerance, prints out message if within tolerance

Not the same, prints if error

Parameters

vec1	Vector
vec2	Vector
tol	1e-9

Returns: bool

Definition at line 62 of file Matrix.cpp.

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 154 of file Vector.cpp.

template<class V >

bool gtsam::assert_inequal	(	const V &	expected,
		const V &	actual,
		double	tol = `1e-9`
	)

Allow for testing inequality

Definition at line 344 of file TestableAssertions.h.

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 379 of file TestableAssertions.h.

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 357 of file TestableAssertions.h.

Rot3_ gtsam::attitude ( const NavState_ & X )

inline

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

template<class V1 , class V2 >

void gtsam::axpy	(	double	alpha,
		const V1 &	x,
		V2 &	y
	)

inline

BLAS Level 1 axpy: y <- alpha*x + y

Deprecated:: : use operators instead

Definition at line 217 of file Vector.h.

void gtsam::axpy	(	double	alpha,
		const Vector &	x,
		SubVector	y
	)

inline

Definition at line 221 of file Vector.h.

template<>

GTSAM_EXPORT void gtsam::axpy< Errors, Errors >	(	double	alpha,
		const Errors &	x,
		Errors &	y
	)

BLAS level 2 style

Definition at line 114 of file Errors.cpp.

template<>

void gtsam::axpy< Errors, Errors >	(	double	alpha,
		const Errors &	x,
		Errors &	y
	)

BLAS level 2 style

Definition at line 114 of file Errors.cpp.

GTSAM_EXPORT 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 366 of file Matrix.cpp.

GTSAM_EXPORT 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

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 376 of file Matrix.cpp.

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 386 of file Matrix.cpp.

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 297 of file Lie.h.

template<typename T >

Expression<T> gtsam::between	(	const Expression< T > &	t1,
		const Expression< T > &	t2
	)

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

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 239 of file Lie.h.

gtsam::BOOST_CONCEPT_ASSERT ( (boost::RandomAccessRangeConcept< ListOfOneContainer< int > >) )

template<typename G >

gtsam::BOOST_CONCEPT_REQUIRES	(	((IsGroup< G >))	,
		(bool)
	)		const

Check invariants.

template<typename T >

gtsam::BOOST_CONCEPT_REQUIRES	(	((IsTestable< T >))	,
		(bool)
	)		const

Check invariants for Manifold type.

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

Definition at line 17 of file PoseRTV.cpp.

boost::shared_ptr< 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 449 of file SubgraphBuilder.cpp.

VectorValues gtsam::buildVectorValues	(	const Vector &	v,
		const Ordering &	ordering,
		const std::map< Key, size_t > &	dimensions
	)

Create VectorValues from a Vector.

Definition at line 140 of file PCGSolver.cpp.

VectorValues gtsam::buildVectorValues	(	const Vector &	v,
		const Ordering &	ordering,
		const map< Key, size_t > &	dimensions
	)

Create VectorValues from a Vector.

Definition at line 140 of file PCGSolver.cpp.

VectorValues gtsam::buildVectorValues	(	const Vector &	v,
		const KeyInfo &	keyInfo
	)

Create VectorValues from a Vector and a KeyInfo class.

Definition at line 161 of file PCGSolver.cpp.

static Point3 gtsam::CalculateBestAxis ( const Point3 & n )

static

Definition at line 64 of file Unit3.cpp.

template<typename Cal , size_t Dim>

void gtsam::calibrateJacobians	(	const Cal &	calibration,
		const Point2 &	pn,
		OptionalJacobian< 2, Dim >	Dcal = `boost::none`,
		OptionalJacobian< 2, 2 >	Dp = `boost::none`
	)

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.

template<typename L >

std::vector<Assignment<L> > gtsam::cartesianProduct ( const std::vector< std::pair< L, size_t > > & keys )

Get Cartesian product consisting all possible configurations.

Parameters

vector list of keys (label,cardinality) pairs.

Returns: vector list of all possible value assignments

This function returns a vector of Assignment values for all possible (Cartesian product) configurations of set of Keys which are nothing but (Label,cardinality) pairs. This function should NOT be called for more than a small number of variables and cardinalities. E.g. For 6 variables with each having cardinalities 4, we get 4096 possible configurations!!

Definition at line 62 of file Assignment.h.

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

static

Definition at line 88 of file NonlinearFactor.cpp.

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 203 of file BayesTree-inst.h.

GTSAM_EXPORT 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 183 of file NonlinearOptimizer.cpp.

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

Definition at line 235 of file NonlinearOptimizer.cpp.

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

static

Definition at line 38 of file GncOptimizer.h.

GTSAM_EXPORT 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 538 of file Matrix.cpp.

GTSAM_EXPORT std::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 76 of file base/cholesky.cpp.

GTSAM_EXPORT 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 108 of file base/cholesky.cpp.

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

inlinestatic

Definition at line 36 of file base/cholesky.cpp.

GTSAM_EXPORT boost::optional< Point2 > gtsam::circleCircleIntersection	(	double	R_d,
		double	r_d,
		double	tol
	)

Definition at line 55 of file Point2.cpp.

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

Definition at line 70 of file Point2.cpp.

GTSAM_EXPORT std::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.

GTSAM_EXPORT 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 442 of file Matrix.cpp.

GTSAM_EXPORT Matrix gtsam::collect	(	size_t	nrMatrices,
			...
	)

Definition at line 467 of file Matrix.cpp.

template<class LinearGraph >

KeyDimMap gtsam::collectKeyDim ( const LinearGraph & linearGraph )

Definition at line 38 of file LP.h.

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 214 of file base/Matrix.h.

GTSAM_EXPORT Vector gtsam::columnNormSquare ( const Matrix & A )

Definition at line 223 of file Matrix.cpp.

template<typename T >

Expression<T> gtsam::compose	(	const Expression< T > &	t1,
		const Expression< T > &	t2
	)

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

template<class G , class Factor , class POSE , class KEY >

boost::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 174 of file graph-inl.h.

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

concatenate Vectors

Definition at line 302 of file Vector.cpp.

GTSAM_EXPORT Vector gtsam::concatVectors	(	size_t	nrVectors,
			...
	)

concatenate Vectors

Definition at line 320 of file Vector.cpp.

GTSAM_EXPORT 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.

GTSAM_EXPORT 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.

GTSAM_EXPORT 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.

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 125 of file iterative-inl.h.

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

static

Definition at line 403 of file dataset.cpp.

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

static

Definition at line 886 of file dataset.cpp.

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

static

Definition at line 965 of file ShonanAveraging.cpp.

GTSAM_EXPORT 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.

static GaussianFactorGraph::shared_ptr gtsam::convertToJacobianFactors ( const GaussianFactorGraph & gfg )

static

Definition at line 80 of file SubgraphPreconditioner.cpp.

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

static

Definition at line 212 of file dataset.cpp.

boost::shared_ptr< Preconditioner > gtsam::createPreconditioner ( const boost::shared_ptr< PreconditionerParameters > params )

Definition at line 186 of file Preconditioner.cpp.

GTSAM_EXPORT 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 100 of file dataset.cpp.

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 100 of file dataset.cpp.

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

Definition at line 378 of file dataset.cpp.

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 256 of file Expression-inl.h.

GTSAM_EXPORT Point3 gtsam::cross	(	const Point3 &	p,
		const Point3 &	q,
		OptionalJacobian< 3, 3 >	H_p = `boost::none`,
		OptionalJacobian< 3, 3 >	H_q = `boost::none`
	)

cross product

Returns: this x q

Definition at line 63 of file Point3.cpp.

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.

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.

std::string GTSAM_EXPORT 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.

template<class T >

void gtsam::deserialize	(	const std::string &	serialized,
		T &	output
	)

deserializes from a string

Definition at line 106 of file base/serialization.h.

template<class T >

void gtsam::deserializeBinary	(	const std::string &	serialized,
		T &	output,
		const std::string &	name = `"data"`
	)

deserializes from a string in binary

Definition at line 253 of file base/serialization.h.

template<class T >

bool gtsam::deserializeFromBinaryFile	(	const std::string &	filename,
		T &	output,
		const std::string &	name = `"data"`
	)

deserializes from a binary file

Definition at line 235 of file base/serialization.h.

template<class T >

void gtsam::deserializeFromBinaryStream	(	std::istream &	in_archive_stream,
		T &	output,
		const std::string &	name = `"data"`
	)

deserializes from a stream in binary

Definition at line 199 of file base/serialization.h.

template<class T >

void gtsam::deserializeFromBinaryString	(	const std::string &	serialized,
		T &	output,
		const std::string &	name = `"data"`
	)

deserializes from a string in binary

Definition at line 216 of file base/serialization.h.

template<class T >

bool gtsam::deserializeFromFile	(	const std::string &	filename,
		T &	output
	)

deserializes from a file

Definition at line 90 of file base/serialization.h.

template<class T >

void gtsam::deserializeFromStream	(	std::istream &	in_archive_stream,
		T &	output
	)

deserializes from a stream

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

template<class T >

void gtsam::deserializeFromString	(	const std::string &	serialized,
		T &	output
	)

deserializes from a string

Definition at line 73 of file base/serialization.h.

template<class T >

bool gtsam::deserializeFromXMLFile	(	const std::string &	filename,
		T &	output,
		const std::string &	name = `"data"`
	)

deserializes from an XML file

Definition at line 161 of file base/serialization.h.

template<class T >

void gtsam::deserializeFromXMLStream	(	std::istream &	in_archive_stream,
		T &	output,
		const std::string &	name = `"data"`
	)

deserializes from a stream in XML

Definition at line 125 of file base/serialization.h.

template<class T >

void gtsam::deserializeFromXMLString	(	const std::string &	serialized,
		T &	output,
		const std::string &	name = `"data"`
	)

deserializes from a string in XML

Definition at line 142 of file base/serialization.h.

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

Definition at line 216 of file serialization.cpp.

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

Definition at line 283 of file serialization.cpp.

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

Definition at line 291 of file serialization.cpp.

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

Definition at line 228 of file serialization.cpp.

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

Definition at line 241 of file serialization.cpp.

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

Definition at line 300 of file serialization.cpp.

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

Definition at line 308 of file serialization.cpp.

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

Definition at line 253 of file serialization.cpp.

template<class T >

void gtsam::deserializeXML	(	const std::string &	serialized,
		T &	output,
		const std::string &	name = `"data"`
	)

deserializes from a string in XML

Definition at line 179 of file base/serialization.h.

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

Create a matrix with submatrices along its diagonal

Definition at line 206 of file Matrix.cpp.

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

static

Definition at line 26 of file ScenarioRunner.h.

GTSAM_EXPORT 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.

GTSAM_EXPORT double gtsam::distance3	(	const Point3 &	p1,
		const Point3 &	q,
		OptionalJacobian< 1, 3 >	H1,
		OptionalJacobian< 1, 3 >	H2
	)

distance between two points

Definition at line 26 of file Point3.cpp.

GTSAM_EXPORT boost::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 567 of file Matrix.cpp.

GTSAM_EXPORT double gtsam::dot	(	const Point3 &	p,
		const Point3 &	q,
		OptionalJacobian< 1, 3 >	H1,
		OptionalJacobian< 1, 3 >	H2
	)

dot product

Definition at line 71 of file Point3.cpp.

GTSAM_EXPORT double gtsam::dot	(	const Errors &	a,
		const Errors &	b
	)

dot product

Definition at line 99 of file Errors.cpp.

template<class V1 , class V2 >

double gtsam::dot	(	const V1 &	a,
		const V2 &	b
	)

inline

Dot product

Definition at line 194 of file Vector.h.

GTSAM_EXPORT 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 199 of file Vector.cpp.

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

Definition at line 532 of file HessianFactor.cpp.

GTSAM_EXPORT std::pair< boost::shared_ptr< DiscreteConditional >, DecisionTreeFactor::shared_ptr > gtsam::EliminateDiscrete	(	const DiscreteFactorGraph &	factors,
		const Ordering &	keys
	)

Main elimination function for DiscreteFactorGraph

Definition at line 105 of file DiscreteFactorGraph.cpp.

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

Definition at line 555 of file HessianFactor.cpp.

GTSAM_EXPORT std::pair< boost::shared_ptr< GaussianConditional >, boost::shared_ptr< JacobianFactor > > 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 797 of file JacobianFactor.cpp.

GTSAM_EXPORT std::pair< boost::shared_ptr< SymbolicConditional >, boost::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 31 of file SymbolicFactor.cpp.

template<class T >

bool gtsam::equal	(	const T &	obj1,
		const T &	obj2,
		double	tol
	)

inline

Call equal on the object

Definition at line 83 of file Testable.h.

template<class T >

bool gtsam::equal	(	const T &	obj1,
		const T &	obj2
	)

inline

Call equal without tolerance (use default tolerance)

Definition at line 89 of file Testable.h.

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

inline

Override of equal in Lie.h

Definition at line 134 of file Vector.h.

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

inline

Override of equal in Lie.h

Definition at line 141 of file Vector.h.

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 84 of file base/Matrix.h.

GTSAM_EXPORT bool gtsam::equal_with_abs_tol	(	const Vector &	vec1,
		const Vector &	vec2,
		double	tol = `1e-9`
	)

VecA == VecB up to tolerance

Definition at line 123 of file Vector.cpp.

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

Definition at line 134 of file Vector.cpp.

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 316 of file Lie.h.

GTSAM_EXPORT 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 588 of file Matrix.cpp.

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 251 of file Lie.h.

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

static

Definition at line 979 of file ShonanAveraging.cpp.

GTSAM_EXPORT 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 65 of file dataset.cpp.

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 65 of file dataset.cpp.

template<class T , typename = typename std::enable_if< std::is_same<gtsam::Rot3, T>::value >::type>

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

Definition at line 45 of file KarcherMeanFactor-inl.h.

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.

template<class T >

T gtsam::FindKarcherMean ( std::initializer_list< T > && rotations )

Definition at line 55 of file KarcherMeanFactor-inl.h.

template<class T , class ALLOC >

T gtsam::FindKarcherMeanImpl ( const vector< T, ALLOC > & rotations )

Definition at line 29 of file KarcherMeanFactor-inl.h.

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 232 of file graph-inl.h.

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

Definition at line 598 of file Matrix.cpp.

GTSAM_EXPORT 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 42 of file Vector.cpp.

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

static

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

template<class T >

GenericValue<T> gtsam::genericValue ( const T & v )

Functional constructor of GenericValue<T> so T can be automatically deduced

Definition at line 212 of file GenericValue.h.

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

static

Definition at line 40 of file SubgraphPreconditioner.cpp.

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.

GTSAM_EXPORT 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 114 of file Vector.cpp.

GTSAM_EXPORT 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 972 of file dataset.cpp.

GTSAM_EXPORT 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 980 of file dataset.cpp.

gtsam::GTSAM_CONCEPT_POSE_INST ( Pose2 )

instantiate concept checks

gtsam::GTSAM_CONCEPT_POSE_INST ( Pose3 )

instantiate concept checks

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 1 )

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 2 )

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 3 )

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 4 )

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 5 )

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 6 )

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 7 )

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 8 )

gtsam::GTSAM_MAKE_MATRIX_DEFS ( 9 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 4 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 5 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 6 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 7 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 8 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 9 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 10 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 11 )

gtsam::GTSAM_MAKE_VECTOR_DEFS ( 12 )

bool GTSAM_EXPORT gtsam::guardedIsDebug ( const std::string & s )

Definition at line 35 of file debug.cpp.

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

Definition at line 43 of file debug.cpp.

GTSAM_EXPORT 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 426 of file GaussianFactorGraph.cpp.

GTSAM_EXPORT std::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 237 of file Vector.cpp.

GTSAM_EXPORT 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 353 of file Matrix.cpp.

GTSAM_EXPORT 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 326 of file Matrix.cpp.

GTSAM_EXPORT double gtsam::houseInPlace ( Vector & x )

beta = house(x) computes the HouseHolder vector in place

Definition at line 212 of file Vector.cpp.

IndexPairVector gtsam::IndexPairSetAsArray ( IndexPairSet & set )

inline

Definition at line 128 of file DSFMap.h.

GTSAM_EXPORT Values gtsam::initialCamerasAndPointsEstimate ( const SfmData & db )

This function creates initial values for cameras and points from db.

Parameters

SfmData

Returns: Values

Definition at line 1284 of file dataset.cpp.

GTSAM_EXPORT Values gtsam::initialCamerasEstimate ( const SfmData & db )

This function creates initial values for cameras from db.

Parameters

SfmData

Returns: Values

Definition at line 1276 of file dataset.cpp.

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 201 of file Vector.h.

GTSAM_EXPORT 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 635 of file Matrix.cpp.

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 198 of file base/Matrix.h.

template<typename T >

T gtsam::interpolate	(	const T &	X,
		const T &	Y,
		double	t
	)

Linear interpolation between X and Y by coefficient t in [0, 1].

Definition at line 325 of file Lie.h.

GTSAM_EXPORT Matrix gtsam::inverse_square_root ( const Matrix & A )

Use Cholesky to calculate inverse square root of a matrix

Definition at line 551 of file Matrix.cpp.

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

static

Definition at line 84 of file Matrix.cpp.

bool GTSAM_EXPORT gtsam::isDebugVersion ( )

Definition at line 50 of file debug.cpp.

template<typename T , size_t d>

static double gtsam::Kappa	(	const BinaryMeasurement< T > &	measurement,
		const ShonanAveragingParameters< d > &	parameters
	)

static

Definition at line 338 of file ShonanAveraging.cpp.

static std::mt19937 gtsam::kRandomNumberGenerator ( 42 )

static

GTSAM_EXPORT bool gtsam::linear_dependent	(	const Matrix &	A,
		const Matrix &	B,
		double	tol = `1e-9`
	)

check whether the rows of two matrices are linear dependent

check whether two vectors are linearly dependent

Parameters

vec1	Vector
vec2	Vector
tol	1e-9

Returns: bool

Definition at line 116 of file Matrix.cpp.

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 181 of file Vector.cpp.

GTSAM_EXPORT 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 102 of file Matrix.cpp.

template<typename T , typename A >

Expression<T> gtsam::linearExpression	(	const boost::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 242 of file Expression.h.

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

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 37 of file factorTesting.h.

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 88 of file NonlinearConjugateGradientOptimizer.h.

template<typename T >

ListOfOneContainer<T> gtsam::ListOfOne ( const T & element )

Factory function for ListOfOneContainer to enable ListOfOne(e) syntax.

Definition at line 139 of file types.h.

GTSAM_EXPORT Matrix gtsam::LLt ( const Matrix & A )

Definition at line 522 of file Matrix.cpp.

GTSAM_EXPORT 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 567 of file dataset.cpp.

GTSAM_EXPORT 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 500 of file dataset.cpp.

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 500 of file dataset.cpp.

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 567 of file dataset.cpp.

GTSAM_EXPORT GraphAndValues gtsam::load2D_robust	(	const std::string &	filename,
		const noiseModel::Base::shared_ptr &	model,
		size_t	maxIndex = `0`
	)

Deprecated:: load2D now allows for arbitrary models and wrapping a robust kernel

Definition at line 575 of file dataset.cpp.

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

Deprecated:: load2D now allows for arbitrary models and wrapping a robust kernel

Definition at line 575 of file dataset.cpp.

GTSAM_EXPORT GraphAndValues gtsam::load3D ( const std::string & filename )

Load TORO 3D Graph.

Definition at line 924 of file dataset.cpp.

GraphAndValues gtsam::load3D ( const string & filename )

Load TORO 3D Graph.

Definition at line 924 of file dataset.cpp.

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 245 of file Lie.h.

static Symbol gtsam::make ( gtsam::Key key )

static

Definition at line 63 of file Symbol.cpp.

static LabeledSymbol gtsam::make ( gtsam::Key key )

static

Definition at line 110 of file LabeledSymbol.cpp.

template<typename T , typename... Args>

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

Add our own make_shared as a layer of wrapping on boost::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 boost::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 boost::shared_ptr<T>

Definition at line 57 of file make_shared.h.

template<typename T , typename... Args>

gtsam::enable_if_t<!needs_eigen_aligned_allocator<T>::value, boost::shared_ptr<T> > gtsam::make_shared ( Args &&... args )

Fall back to the boost version if no need for alignment.

Definition at line 63 of file make_shared.h.

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 142 of file FunctorizedFactor.h.

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 249 of file FunctorizedFactor.h.

const Eigen::IOFormat & gtsam::matlabFormat ( )

Definition at line 139 of file Matrix.cpp.

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 192 of file ActiveSetSolver.h.

template<class CONTAINER >

Point3 gtsam::mean ( const CONTAINER & points )

mean

Definition at line 66 of file Point3.h.

GTSAM_EXPORT Point3Pair gtsam::means ( const std::vector< Point3Pair > & abPointPairs )

Calculate the two means of a set of Point3 pairs.

Definition at line 78 of file Point3.cpp.

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.

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 126 of file LabeledSymbol.h.

unsigned char gtsam::mrsymbolChr ( Key key )

inline

Return the character portion of a symbol key.

Definition at line 131 of file LabeledSymbol.h.

size_t gtsam::mrsymbolIndex ( Key key )

inline

Return the index portion of a symbol key.

Definition at line 137 of file LabeledSymbol.h.

unsigned char gtsam::mrsymbolLabel ( Key key )

inline

Return the label portion of a symbol key.

Definition at line 134 of file LabeledSymbol.h.

template<class S , class V >

boost::tuple<V, int> gtsam::nonlinearConjugateGradient	(	const S &	system,
		const V &	initial,
		const NonlinearOptimizerParams &	params,
		const bool	singleIteration,
		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 148 of file NonlinearConjugateGradientOptimizer.h.

GTSAM_EXPORT 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.

GTSAM_EXPORT double gtsam::norm3	(	const Point3 &	p,
		OptionalJacobian< 1, 3 >	H
	)

Distance of the point from the origin, with Jacobian.

Definition at line 40 of file Point3.cpp.

GTSAM_EXPORT Point3 gtsam::normalize	(	const Point3 &	p,
		OptionalJacobian< 3, 3 >	H
	)

normalize, with optional Jacobian

Definition at line 51 of file Point3.cpp.

static void gtsam::normalize ( Signature::Row & row )

static

Definition at line 158 of file Signature.cpp.

template<size_t d>

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

static

Definition at line 102 of file ShonanAveraging.cpp.

template<class Y , class X , int N = traits<X>::dimension>

internal::FixedSizeMatrix<Y, X>::type gtsam::numericalDerivative11	(	boost::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 118 of file numericalDerivative.h.

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 158 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , int N = traits<X1>::dimension>

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative21	(	const boost::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 173 of file numericalDerivative.h.

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 184 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , int N = traits<X2>::dimension>

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative22	(	boost::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 199 of file numericalDerivative.h.

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 210 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , class X3 , int N = traits<X1>::dimension>

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative31	(	boost::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 227 of file numericalDerivative.h.

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 238 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , class X3 , int N = traits<X2>::dimension>

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative32	(	boost::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 256 of file numericalDerivative.h.

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 267 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , class X3 , int N = traits<X3>::dimension>

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative33	(	boost::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 285 of file numericalDerivative.h.

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 296 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X1>::dimension>

internal::FixedSizeMatrix<Y,X1>::type gtsam::numericalDerivative41	(	boost::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 314 of file numericalDerivative.h.

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 325 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X2>::dimension>

internal::FixedSizeMatrix<Y,X2>::type gtsam::numericalDerivative42	(	boost::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 342 of file numericalDerivative.h.

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 353 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X3>::dimension>

internal::FixedSizeMatrix<Y,X3>::type gtsam::numericalDerivative43	(	boost::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 370 of file numericalDerivative.h.

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 381 of file numericalDerivative.h.

template<class Y , class X1 , class X2 , class X3 , class X4 , int N = traits<X4>::dimension>

internal::FixedSizeMatrix<Y,X4>::type gtsam::numericalDerivative44	(	boost::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 398 of file numericalDerivative.h.

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 409 of file numericalDerivative.h.

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	(	boost::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 427 of file numericalDerivative.h.

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 438 of file numericalDerivative.h.

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	(	boost::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 456 of file numericalDerivative.h.

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 467 of file numericalDerivative.h.

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	(	boost::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 485 of file numericalDerivative.h.

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 496 of file numericalDerivative.h.

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	(	boost::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 514 of file numericalDerivative.h.

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 525 of file numericalDerivative.h.

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	(	boost::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 543 of file numericalDerivative.h.

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 554 of file numericalDerivative.h.

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	(	boost::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 573 of file numericalDerivative.h.

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 584 of file numericalDerivative.h.

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	(	boost::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 603 of file numericalDerivative.h.

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 614 of file numericalDerivative.h.

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	(	boost::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 633 of file numericalDerivative.h.

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 644 of file numericalDerivative.h.

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	(	boost::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 663 of file numericalDerivative.h.

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 674 of file numericalDerivative.h.

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	(	boost::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 693 of file numericalDerivative.h.

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 704 of file numericalDerivative.h.

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	(	boost::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 723 of file numericalDerivative.h.

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 735 of file numericalDerivative.h.

template<class X , int N = traits<X>::dimension>

Eigen::Matrix<double, N, 1> gtsam::numericalGradient	(	boost::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 78 of file numericalDerivative.h.

template<class X >

internal::FixedSizeMatrix<X,X>::type gtsam::numericalHessian	(	boost::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 749 of file numericalDerivative.h.

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 762 of file numericalDerivative.h.

template<class X1 , class X2 >

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

inline

Definition at line 806 of file numericalDerivative.h.

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 822 of file numericalDerivative.h.

template<class X1 , class X2 >

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

inline

Definition at line 788 of file numericalDerivative.h.

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 799 of file numericalDerivative.h.

template<class X1 , class X2 >

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

inline

Definition at line 829 of file numericalDerivative.h.

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 843 of file numericalDerivative.h.