Renaming IkSampleableConstraint and FiniteSampleConstraint

aikido/include/aikido/constraint/FiniteSampleConstraint.hpp → aikido/include/aikido/constraint/FiniteSampleable.hpp

@@ -1,5 +1,5 @@
-#ifndef AIKIDO_CONSTRAINT_FINITESAMPLECONSTRAINT_HPP_
-#define AIKIDO_CONSTRAINT_FINITESAMPLECONSTRAINT_HPP_
+#ifndef AIKIDO_CONSTRAINT_FINITESAMPLEABLE_HPP_
+#define AIKIDO_CONSTRAINT_FINITESAMPLEABLE_HPP_
 
 #include "Sampleable.hpp"
 
@@ -9,33 +9,33 @@ namespace constraint {
 /// Constraint that always returns a finite set of samples.
 /// Its SampleGenerator will generate sample 
 /// until all samples are exhausted.
-class FiniteSampleConstraint : public SampleableConstraint
+class FiniteSampleable : public SampleableConstraint
 {
 public:
   /// Constructor for single-sample constraint.
   /// \param _stateSpace StateSpace in which _state belongs.
   /// \param _state The only sample in this constraint.
-  FiniteSampleConstraint(
+  FiniteSampleable(
     statespace::StateSpacePtr _stateSpace,
     const statespace::StateSpace::State* _state);
 
   /// Constructor for multiple samples.
   /// \param _stateSpace StateSpace in which _states belong.
   /// \param _states Samples in this constraint.
   ///        SampleGenerator will generate samples in this order.
-  FiniteSampleConstraint(
+  FiniteSampleable(
     statespace::StateSpacePtr _stateSpace,
     const std::vector<const statespace::StateSpace::State*>& _states);
 
-  FiniteSampleConstraint(const FiniteSampleConstraint& other) = delete;
-  FiniteSampleConstraint(FiniteSampleConstraint&& other) = delete;
+  FiniteSampleable(const FiniteSampleable& other) = delete;
+  FiniteSampleable(FiniteSampleable&& other) = delete;
 
-  FiniteSampleConstraint& operator=(
-    const FiniteSampleConstraint& other) = delete;
-  FiniteSampleConstraint& operator=(
-    FiniteSampleConstraint&& other) = delete;
+  FiniteSampleable& operator=(
+    const FiniteSampleable& other) = delete;
+  FiniteSampleable& operator=(
+    FiniteSampleable&& other) = delete;
 
-  virtual ~FiniteSampleConstraint();
+  virtual ~FiniteSampleable();
 
   // Documentation inherited.
   statespace::StateSpacePtr getStateSpace() const override;

aikido/include/aikido/constraint/IkSampleableConstraint.hpp → aikido/include/aikido/constraint/InverseKinematicsSampleable.hpp

@@ -1,5 +1,5 @@
-#ifndef AIKIDO_CONSTRAINT_IKSAMPLEABLECONSTRAINT_HPP_
-#define AIKIDO_CONSTRAINT_IKSAMPLEABLECONSTRAINT_HPP_
+#ifndef AIKIDO_CONSTRAINT_INVERSEKINEMATICSSAMPLEABLEABLE_HPP_
+#define AIKIDO_CONSTRAINT_INVERSEKINEMATICSSAMPLEABLEABLE_HPP_
 
 #include "Sampleable.hpp"
 #include "../statespace/dart/MetaSkeletonStateSpace.hpp"
@@ -15,7 +15,7 @@ namespace constraint {
 /// into the metaskeleton's configuration space. This class will retry a
 /// configurable number of times if sampling from the provided sampleable
 /// pose constraint or finding an inverse kinematic solution fails.
-class IkSampleableConstraint : public SampleableConstraint
+class InverseKinematicsSampleable : public SampleableConstraint
 {
 public:
 
@@ -29,14 +29,14 @@ class IkSampleableConstraint : public SampleableConstraint
   ///        sampled by _poseConstaint.
   /// \param _maxNumTrials Max number of trials for its sample generator
   ///        to retry sampling and finding an inverse kinematics solution.
-  IkSampleableConstraint(
+  InverseKinematicsSampleable(
     statespace::dart::MetaSkeletonStateSpacePtr _stateSpace,
     SampleableConstraintPtr _poseConstraint,
     SampleableConstraintPtr _seedConstraint,
     dart::dynamics::InverseKinematicsPtr _inverseKinematics,
     int _maxNumTrials);
 
-  virtual ~IkSampleableConstraint() = default;
+  virtual ~InverseKinematicsSampleable() = default;
 
   // Documentation inherited.
   virtual statespace::StateSpacePtr getStateSpace() const override;
@@ -56,4 +56,4 @@ class IkSampleableConstraint : public SampleableConstraint
 } // namespace constraint 
 } // namespace aikido
 
-#endif // AIKIDO_CONSTRAINT_IKSAMPLEABLECONSTRAINT_HPP_
+#endif // AIKIDO_CONSTRAINT_INVERSEKINEMATICSSAMPLEABLE_HPP_

aikido/src/constraint/CMakeLists.txt

@@ -5,12 +5,12 @@ aikido_add_library("${PROJECT_NAME}_constraint"
   Differentiable.cpp
   DifferentiableProjector.cpp
   DifferentiableSubSpace.cpp
-  FiniteSampleConstraint.cpp
+  FiniteSampleable.cpp
   CyclicSampleable.cpp
   FkTestable.cpp
   FrameConstraintAdaptor.cpp
   FramePairConstraintAdaptor.cpp
-  IkSampleableConstraint.cpp
+  InverseKinematicsSampleable.cpp
   NonColliding.cpp
   Projectable.cpp
   ProjectableSubSpace.cpp

aikido/src/constraint/FiniteSampleConstraint.cpp → aikido/src/constraint/FiniteSampleable.cpp

@@ -1,4 +1,4 @@
-#include <aikido/constraint/FiniteSampleConstraint.hpp>
+#include <aikido/constraint/FiniteSampleable.hpp>
 #include <dart/common/StlHelpers.h>
 
 namespace aikido {
@@ -42,7 +42,7 @@ class FiniteSampleGenerator : public SampleGenerator
   std::vector<statespace::StateSpace::State*> mStates;
   int mIndex;
 
-  friend class FiniteSampleConstraint;
+  friend class FiniteSampleable;
 };
 
 //=============================================================================
@@ -117,7 +117,7 @@ bool FiniteSampleGenerator::canSample() const
 }
 
 //=============================================================================
-FiniteSampleConstraint::FiniteSampleConstraint(
+FiniteSampleable::FiniteSampleable(
   statespace::StateSpacePtr _stateSpace,
   const statespace::StateSpace::State* _state)
 : mStateSpace(std::move(_stateSpace))
@@ -136,7 +136,7 @@ FiniteSampleConstraint::FiniteSampleConstraint(
 
 
 //=============================================================================
-FiniteSampleConstraint::FiniteSampleConstraint(
+FiniteSampleable::FiniteSampleable(
   statespace::StateSpacePtr _stateSpace,
     const std::vector<const statespace::StateSpace::State*>& _states)
 : mStateSpace(std::move(_stateSpace))
@@ -168,7 +168,7 @@ FiniteSampleConstraint::FiniteSampleConstraint(
 }
 
 //=============================================================================
-FiniteSampleConstraint::~FiniteSampleConstraint()
+FiniteSampleable::~FiniteSampleable()
 {
   for (auto state: mStates)
   {
@@ -177,13 +177,13 @@ FiniteSampleConstraint::~FiniteSampleConstraint()
 }
 
 //=============================================================================
-statespace::StateSpacePtr FiniteSampleConstraint::getStateSpace() const
+statespace::StateSpacePtr FiniteSampleable::getStateSpace() const
 {
   return mStateSpace;
 }
 
 //=============================================================================
-std::unique_ptr<SampleGenerator> FiniteSampleConstraint::createSampleGenerator() const
+std::unique_ptr<SampleGenerator> FiniteSampleable::createSampleGenerator() const
 {
   return dart::common::make_unique<FiniteSampleGenerator>(mStateSpace, mStates);
 }

aikido/src/constraint/IkSampleableConstraint.cpp → aikido/src/constraint/InverseKinematicsSampleable.cpp

@@ -1,4 +1,4 @@
-#include <aikido/constraint/IkSampleableConstraint.hpp>
+#include <aikido/constraint/InverseKinematicsSampleable.hpp>
 #include <aikido/statespace/SE3.hpp>
 
 namespace aikido {
@@ -51,12 +51,12 @@ class IkSampleGenerator : public SampleGenerator
   std::unique_ptr<SampleGenerator> mSeedSampler;
   int mMaxNumTrials;
 
-  friend class IkSampleableConstraint;
+  friend class InverseKinematicsSampleable;
 };
 
 
 //=============================================================================
-IkSampleableConstraint::IkSampleableConstraint(
+InverseKinematicsSampleable::InverseKinematicsSampleable(
       MetaSkeletonStateSpacePtr _stateSpace,
       SampleableConstraintPtr _poseConstraint,
       SampleableConstraintPtr _seedConstraint,
@@ -108,14 +108,14 @@ IkSampleableConstraint::IkSampleableConstraint(
 }
 
 //=============================================================================
-statespace::StateSpacePtr IkSampleableConstraint::getStateSpace() const
+statespace::StateSpacePtr InverseKinematicsSampleable::getStateSpace() const
 {
   return mStateSpace;
 }
 
 //=============================================================================
 std::unique_ptr<SampleGenerator>
-  IkSampleableConstraint::createSampleGenerator() const
+  InverseKinematicsSampleable::createSampleGenerator() const
 {
   return std::unique_ptr<IkSampleGenerator>(new IkSampleGenerator(
     mStateSpace,

aikido/tests/constraint/CMakeLists.txt

@@ -20,9 +20,9 @@ aikido_add_test(test_FramePairConstraintAdaptor
 target_link_libraries(test_FramePairConstraintAdaptor
   "${PROJECT_NAME}_constraint")
 
-aikido_add_test(test_IkSampleableConstraint
-  test_IkSampleableConstraint.cpp)
-target_link_libraries(test_IkSampleableConstraint
+aikido_add_test(test_InverseKinematicsSampleable
+  test_InverseKinematicsSampleable.cpp)
+target_link_libraries(test_InverseKinematicsSampleable
   "${PROJECT_NAME}_constraint")
 
 # aikido_add_test(test_PolynomialConstraint
@@ -55,9 +55,9 @@ aikido_add_test(test_SO2UniformSampler
 target_link_libraries(test_SO2UniformSampler
   "${PROJECT_NAME}_constraint" "${PROJECT_NAME}_distance")
 
-aikido_add_test(test_FiniteSampleConstraint
-  test_FiniteSampleConstraint.cpp)
-target_link_libraries(test_FiniteSampleConstraint
+aikido_add_test(test_FiniteSampleable
+  test_FiniteSampleable.cpp)
+target_link_libraries(test_FiniteSampleable
   "${PROJECT_NAME}_constraint")
 
 aikido_add_test(test_CyclicSampleable

aikido/tests/constraint/test_CyclicSampleable.cpp

@@ -1,5 +1,5 @@
 #include <aikido/constraint/CyclicSampleable.hpp>
-#include <aikido/constraint/FiniteSampleConstraint.hpp>
+#include <aikido/constraint/FiniteSampleable.hpp>
 #include <aikido/constraint/uniform/SO2UniformSampler.hpp>
 #include <aikido/statespace/SO2.hpp>
 #include <aikido/statespace/Rn.hpp>
@@ -13,7 +13,7 @@ using aikido::statespace::SO2;
 using aikido::statespace::SO2SampleableConstraint;
 using aikido::statespace::Rn;
 using aikido::constraint::CyclicSampleable;
-using aikido::constraint::FiniteSampleConstraint;
+using aikido::constraint::FiniteSampleable;
 using aikido::constraint::SampleGenerator;
 using State = aikido::statespace::StateSpace::State;
 using dart::common::make_unique;
@@ -50,7 +50,7 @@ TEST(CyclicSampleableTest, SingleState)
   s1.setValue(v);
 
   // Single-sample-constraint.
-  std::shared_ptr<FiniteSampleConstraint> constraint = std::make_shared<FiniteSampleConstraint>(
+  std::shared_ptr<FiniteSampleable> constraint = std::make_shared<FiniteSampleable>(
     std::make_shared<Rn>(rvss), s1);
 
   // Single-sample-cyclic-constraint.
@@ -93,8 +93,8 @@ TEST(CyclicSampleableTest, MultipleStates)
   states.push_back(s2);
 
   // Finite-sample constraint
-  std::shared_ptr<FiniteSampleConstraint> constraint = 
-    std::make_shared<FiniteSampleConstraint>(
+  std::shared_ptr<FiniteSampleable> constraint = 
+    std::make_shared<FiniteSampleable>(
     std::make_shared<Rn>(rvss), states);
 
   // Finite-sample cyclic constraint

aikido/tests/constraint/test_FiniteSampleConstraint.cpp → aikido/tests/constraint/test_FiniteSampleable.cpp

@@ -1,54 +1,54 @@
 #include "../eigen_tests.hpp"
-#include <aikido/constraint/FiniteSampleConstraint.hpp>
+#include <aikido/constraint/FiniteSampleable.hpp>
 #include <aikido/statespace/Rn.hpp>
 #include <aikido/statespace/StateSpace.hpp>
 
 #include <gtest/gtest.h>
 
 using aikido::statespace::Rn;
-using aikido::constraint::FiniteSampleConstraint;
+using aikido::constraint::FiniteSampleable;
 using aikido::constraint::SampleGenerator;
 using State = aikido::statespace::StateSpace::State;
 
-TEST(FiniteSampleConstraintTest, ConstructorThrowsOnNullStateSpace)
+TEST(FiniteSampleableTest, ConstructorThrowsOnNullStateSpace)
 {
   Rn rvss(1);
   auto s1 = rvss.createState();
   s1.setValue(aikido::tests::make_vector(5));
 
-  EXPECT_THROW(FiniteSampleConstraint(nullptr, s1), std::invalid_argument);
+  EXPECT_THROW(FiniteSampleable(nullptr, s1), std::invalid_argument);
 
   std::vector<const aikido::statespace::StateSpace::State*> states;
   states.push_back(s1);
-  EXPECT_THROW(FiniteSampleConstraint(nullptr, states), std::invalid_argument);
+  EXPECT_THROW(FiniteSampleable(nullptr, states), std::invalid_argument);
 }
 
 
-TEST(FiniteSampleConstraintTest, ConstructorThrowsOnNullState)
+TEST(FiniteSampleableTest, ConstructorThrowsOnNullState)
 {
   auto rvss = std::make_shared<Rn>(1);
   Rn::State* st = 0;
 
-  EXPECT_THROW(FiniteSampleConstraint(rvss, st), std::invalid_argument);
+  EXPECT_THROW(FiniteSampleable(rvss, st), std::invalid_argument);
 }
 
-TEST(FiniteSampleConstraintTest, ConstructorThrowsOnEmptyStates)
+TEST(FiniteSampleableTest, ConstructorThrowsOnEmptyStates)
 {
   auto rvss = std::make_shared<Rn>(1);
   std::vector<const aikido::statespace::StateSpace::State*> states;
-  EXPECT_THROW(FiniteSampleConstraint(rvss, states), std::invalid_argument);
+  EXPECT_THROW(FiniteSampleable(rvss, states), std::invalid_argument);
 }
 
-TEST(FiniteSampleConstraintTest, StateSpaceMatch){
+TEST(FiniteSampleableTest, StateSpaceMatch){
   auto rvss = std::make_shared<Rn>(1);
   Eigen::VectorXd v = aikido::tests::make_vector(-2);
   auto s1 = rvss->createState();
   s1.setValue(v);
-  FiniteSampleConstraint constraint(rvss, s1);
+  FiniteSampleable constraint(rvss, s1);
   EXPECT_EQ(rvss, constraint.getStateSpace());
 }
 
-TEST(FiniteSampleConstraintTest, SingleSampleGenerator)
+TEST(FiniteSampleableTest, SingleSampleGenerator)
 {
   // Single-sample.
   Eigen::VectorXd v = aikido::tests::make_vector(-2);
@@ -58,7 +58,7 @@ TEST(FiniteSampleConstraintTest, SingleSampleGenerator)
   s1.setValue(v);
 
   // Single-sample constraint.
-  FiniteSampleConstraint constraint(
+  FiniteSampleable constraint(
   	std::make_shared<Rn>(rvss), s1);
 
   // Single-sample-generator.
@@ -78,7 +78,7 @@ TEST(FiniteSampleConstraintTest, SingleSampleGenerator)
 
 }
 
-TEST(FiniteSampleConstraintTest, FiniteSampleGenerator)
+TEST(FiniteSampleableTest, FiniteSampleGenerator)
 {
 
   // Finite-samples
@@ -101,7 +101,7 @@ TEST(FiniteSampleConstraintTest, FiniteSampleGenerator)
   states.push_back(s2);
 
   // Finite-sample-constraint.
-  FiniteSampleConstraint constraint(
+  FiniteSampleable constraint(
     std::make_shared<Rn>(rvss), states);
 
   // Finite-sample generator.