aikido::constraint Namespace Reference

Namespaces
	dart
	uniform

Classes
class	CartesianProductProjectable
	A Projectable for CompoundStates. More...
class	CartesianProductSampleable
	Sampleable for CompoundStates. More...
class	CartesianProductTestable
	Testable for CompoundStates. More...
class	CyclicSampleable
	Constraint that turns a finite sampleable constraint into a cyclic sampleable constraint. More...
class	DefaultTestableOutcome
	Simple default TestableOutcome derivative class. More...
class	Differentiable
	A differentiable constraint. More...
class	DifferentiableIntersection
	Contains n constraints that take the same statespace. More...
class	DifferentiableSubspace
	A differentiable constraint applied only on a subspace of a CompoundState. More...
class	FiniteSampleable
	Constraint that always returns a finite set of samples. More...
class	NewtonsMethodProjectable
	Uses Newton's method to project state. More...
class	Projectable
	A projectable constraint. More...
class	RejectionSampleable
	Rejection-based sampleable. More...
class	Sampleable
	Constraint that may be sampled from. More...
class	SampleGenerator
	Generator for drawing samples from a Sampleable. More...
class	Satisfied
	A constraint which is always satisfied. More...
class	SequentialSampleable
	Sampleable that wraps a sequence of Sampleables. More...
class	Testable
	Constraint which can be tested. More...
class	TestableIntersection
	A testable constraint grouping a set of testable constraint. More...
class	TestableOutcome
	Base class for constraint outcomes. More...

Typedefs
using	DifferentiablePtr = std::shared_ptr< Differentiable >
using	ConstDifferentiablePtr = std::shared_ptr< const Differentiable >
using	WeakDifferentiablePtr = std::weak_ptr< Differentiable >
using	WeakConstDifferentiablePtr = std::weak_ptr< const Differentiable >
using	UniqueDifferentiablePtr = std::unique_ptr< Differentiable >
using	UniqueConstDifferentiablePtr = std::unique_ptr< const Differentiable >
using	ProjectablePtr = std::shared_ptr< Projectable >
using	SampleablePtr = std::shared_ptr< Sampleable >
using	ConstSampleablePtr = std::shared_ptr< const Sampleable >
using	WeakSampleablePtr = std::weak_ptr< Sampleable >
using	WeakConstSampleablePtr = std::weak_ptr< const Sampleable >
using	UniqueSampleablePtr = std::unique_ptr< Sampleable >
using	UniqueConstSampleablePtr = std::unique_ptr< const Sampleable >
using	TestablePtr = std::shared_ptr< Testable >
using	ConstTestablePtr = std::shared_ptr< const Testable >
using	WeakTestablePtr = std::weak_ptr< Testable >
using	WeakConstTestablePtr = std::weak_ptr< const Testable >
using	UniqueTestablePtr = std::unique_ptr< Testable >
using	UniqueConstTestablePtr = std::unique_ptr< const Testable >
using	TestableIntersectionPtr = std::shared_ptr< TestableIntersection >
using	ConstTestableIntersectionPtr = std::shared_ptr< const TestableIntersection >
using	WeakTestableIntersectionPtr = std::weak_ptr< TestableIntersection >
using	WeakConstTestableIntersectionPtr = std::weak_ptr< const TestableIntersection >
using	UniqueTestableIntersectionPtr = std::unique_ptr< TestableIntersection >
using	UniqueConstTestableIntersectionPtr = std::unique_ptr< const TestableIntersection >

Enumerations
enum	ConstraintType { ConstraintType::EQUALITY, ConstraintType::INEQUALITY }
	Enum for classifying constraints used in Differentiable. More...

Functions
template<class Child >
Child *	dynamic_cast_or_throw (TestableOutcome *outcome)
	Helper function. More...

Typedef Documentation

ConstDifferentiablePtr

using aikido::constraint::ConstDifferentiablePtr = typedef std::shared_ptr< const Differentiable >

ConstSampleablePtr

using aikido::constraint::ConstSampleablePtr = typedef std::shared_ptr< const Sampleable >

ConstTestableIntersectionPtr

using aikido::constraint::ConstTestableIntersectionPtr = typedef std::shared_ptr< const TestableIntersection >

ConstTestablePtr

using aikido::constraint::ConstTestablePtr = typedef std::shared_ptr< const Testable >

DifferentiablePtr

using aikido::constraint::DifferentiablePtr = typedef std::shared_ptr< Differentiable >

ProjectablePtr

using aikido::constraint::ProjectablePtr = typedef std::shared_ptr<Projectable>

SampleablePtr

using aikido::constraint::SampleablePtr = typedef std::shared_ptr< Sampleable >

TestableIntersectionPtr

using aikido::constraint::TestableIntersectionPtr = typedef std::shared_ptr< TestableIntersection >

TestablePtr

using aikido::constraint::TestablePtr = typedef std::shared_ptr< Testable >

UniqueConstDifferentiablePtr

using aikido::constraint::UniqueConstDifferentiablePtr = typedef std::unique_ptr< const Differentiable >

UniqueConstSampleablePtr

using aikido::constraint::UniqueConstSampleablePtr = typedef std::unique_ptr< const Sampleable >

UniqueConstTestableIntersectionPtr

using aikido::constraint::UniqueConstTestableIntersectionPtr = typedef std::unique_ptr< const TestableIntersection >

UniqueConstTestablePtr

using aikido::constraint::UniqueConstTestablePtr = typedef std::unique_ptr< const Testable >

UniqueDifferentiablePtr

using aikido::constraint::UniqueDifferentiablePtr = typedef std::unique_ptr< Differentiable >

UniqueSampleablePtr

using aikido::constraint::UniqueSampleablePtr = typedef std::unique_ptr< Sampleable >

UniqueTestableIntersectionPtr

using aikido::constraint::UniqueTestableIntersectionPtr = typedef std::unique_ptr< TestableIntersection >

UniqueTestablePtr

using aikido::constraint::UniqueTestablePtr = typedef std::unique_ptr< Testable >

WeakConstDifferentiablePtr

using aikido::constraint::WeakConstDifferentiablePtr = typedef std::weak_ptr< const Differentiable >

WeakConstSampleablePtr

using aikido::constraint::WeakConstSampleablePtr = typedef std::weak_ptr< const Sampleable >

WeakConstTestableIntersectionPtr

using aikido::constraint::WeakConstTestableIntersectionPtr = typedef std::weak_ptr< const TestableIntersection >

WeakConstTestablePtr

using aikido::constraint::WeakConstTestablePtr = typedef std::weak_ptr< const Testable >

WeakDifferentiablePtr

using aikido::constraint::WeakDifferentiablePtr = typedef std::weak_ptr< Differentiable >

WeakSampleablePtr

using aikido::constraint::WeakSampleablePtr = typedef std::weak_ptr< Sampleable >

WeakTestableIntersectionPtr

using aikido::constraint::WeakTestableIntersectionPtr = typedef std::weak_ptr< TestableIntersection >

WeakTestablePtr

using aikido::constraint::WeakTestablePtr = typedef std::weak_ptr< Testable >

Enumeration Type Documentation

ConstraintType

enum aikido::constraint::ConstraintType

strong

Enum for classifying constraints used in Differentiable.

Equality constraint is satisfied by f(x) = 0. Inequality constraint is satisfied by f(x) <= 0.

Enumerator
EQUALITY
INEQUALITY

Function Documentation

dynamic_cast_or_throw()

template<class Child >

Child * aikido::constraint::dynamic_cast_or_throw

(

TestableOutcome *

outcome

)

Helper function.

Avoids repeating logic for casting TestableOutcome pointers down to pointers for a derivative class. Mostly used in the isSatisfied methods of classes that inherit Testable.