Index: src/Parameters/ContinuousValue.hpp
===================================================================
--- src/Parameters/ContinuousValue.hpp	(revision 85d89b9a61c8e0abafadf1dd80be697dab94f94b)
+++ src/Parameters/ContinuousValue.hpp	(revision 7d1b6a327479949780b8727cdc38154708663bf5)
@@ -16,5 +16,5 @@
 #include <string>
 
-#include "CodePatterns/Range.hpp"
+#include "Range.hpp"
 
 #include "ValueInterface.hpp"
Index: src/Parameters/ContinuousValue_impl.hpp
===================================================================
--- src/Parameters/ContinuousValue_impl.hpp	(revision 85d89b9a61c8e0abafadf1dd80be697dab94f94b)
+++ src/Parameters/ContinuousValue_impl.hpp	(revision 7d1b6a327479949780b8727cdc38154708663bf5)
@@ -20,5 +20,5 @@
 #include "CodePatterns/Assert.hpp"
 #include "CodePatterns/Log.hpp"
-#include "CodePatterns/Range.hpp"
+#include "Range.hpp"
 
 #include "ContinuousValue.hpp"
Index: src/Parameters/unittests/ContinuousParameterTest.cpp
===================================================================
--- src/Parameters/unittests/ContinuousParameterTest.cpp	(revision 85d89b9a61c8e0abafadf1dd80be697dab94f94b)
+++ src/Parameters/unittests/ContinuousParameterTest.cpp	(revision 7d1b6a327479949780b8727cdc38154708663bf5)
@@ -26,5 +26,5 @@
 #include "Parameters/ContinuousParameter.hpp"
 
-#include "CodePatterns/Range.hpp"
+#include "../Range.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -41,10 +41,12 @@
   ASSERT_DO(Assert::Throw);
 
-  ValidRange = new range<int>(1,4);
+  ValidIntRange = new range<int>(1,4);
+  ValidVectorRange = new range<Vector>(Vector(0,1,2), Vector(10,11,12));
 }
 
 void ContinuousParameterTest::tearDown()
 {
-  delete ValidRange;
+  delete ValidIntRange;
+  delete ValidVectorRange;
 }
 
@@ -57,9 +59,9 @@
 {
   // create instance
-  ContinuousParameter<int> test("intParam", *ValidRange);
-  ContinuousParameter<int> samenamedsamevalued("intParam", *ValidRange);
-  ContinuousParameter<int> samenamedelsevalued("intParam", *ValidRange);
-  ContinuousParameter<int> elsenamedsamevalued("int2Param", *ValidRange);
-  ContinuousParameter<int> elsenamedelsevalued("int2Param", *ValidRange);
+  ContinuousParameter<int> test("intParam", *ValidIntRange);
+  ContinuousParameter<int> samenamedsamevalued("intParam", *ValidIntRange);
+  ContinuousParameter<int> samenamedelsevalued("intParam", *ValidIntRange);
+  ContinuousParameter<int> elsenamedsamevalued("int2Param", *ValidIntRange);
+  ContinuousParameter<int> elsenamedelsevalued("int2Param", *ValidIntRange);
   test.setValue(1);
   samenamedsamevalued.setValue(1);
@@ -80,5 +82,5 @@
 {
   // create instance
-  ContinuousParameter<int> test("intParam", *ValidRange);
+  ContinuousParameter<int> test("intParam", *ValidIntRange);
 
   // check that we throw because of unset parameter
Index: src/Parameters/unittests/ContinuousParameterTest.hpp
===================================================================
--- src/Parameters/unittests/ContinuousParameterTest.hpp	(revision 85d89b9a61c8e0abafadf1dd80be697dab94f94b)
+++ src/Parameters/unittests/ContinuousParameterTest.hpp	(revision 7d1b6a327479949780b8727cdc38154708663bf5)
@@ -17,5 +17,8 @@
 #include <cppunit/extensions/HelperMacros.h>
 
+#include "LinearAlgebra/Vector.hpp"
+
 template<class T> struct range;
+class Vector;
 
 class ContinuousParameterTest :  public CppUnit::TestFixture
@@ -34,5 +37,6 @@
 
 private:
-  range<int> *ValidRange;
+  range<int> *ValidIntRange;
+  range<Vector> *ValidVectorRange;
 };
 
Index: src/Parameters/unittests/ContinuousValueTest.cpp
===================================================================
--- src/Parameters/unittests/ContinuousValueTest.cpp	(revision 85d89b9a61c8e0abafadf1dd80be697dab94f94b)
+++ src/Parameters/unittests/ContinuousValueTest.cpp	(revision 7d1b6a327479949780b8727cdc38154708663bf5)
@@ -39,10 +39,12 @@
   ASSERT_DO(Assert::Throw);
 
-  ValidRange = new range<int>(1,4);
+  ValidIntRange = new range<int>(1,4);
+  ValidVectorRange = new range<Vector>(Vector(0,1,2), Vector(10,11,12));
 }
 
 void ContinuousValueTest::tearDown()
 {
-  delete ValidRange;
+  delete ValidIntRange;
+  delete ValidVectorRange;
 }
 
@@ -52,8 +54,8 @@
  *
  */
-void ContinuousValueTest::isValidValueTest()
-{
-  // create instance
-  ContinuousValue<int> test(*ValidRange);
+void ContinuousValueTest::isValidIntValueTest()
+{
+  // create instance
+  ContinuousValue<int> test(*ValidIntRange);
 
   // checking valid values
@@ -71,8 +73,8 @@
  *
  */
-void ContinuousValueTest::isValidTest()
-{
-  // create instance
-  ContinuousValue<int> test(*ValidRange);
+void ContinuousValueTest::isValidIntTest()
+{
+  // create instance
+  ContinuousValue<int> test(*ValidIntRange);
 
   // checking valid values
@@ -90,9 +92,9 @@
  *
  */
-void ContinuousValueTest::setgetValidRangeTest()
-{
-  {
-    // create instance
-    ContinuousValue<int> test(*ValidRange);
+void ContinuousValueTest::setgetValidIntRangeTest()
+{
+  {
+    // create instance
+    ContinuousValue<int> test(*ValidIntRange);
 
     // extending range and checking
@@ -106,5 +108,5 @@
   {
     // create instance
-    ContinuousValue<int> test(*ValidRange);
+    ContinuousValue<int> test(*ValidIntRange);
 
     // lowering range with set value
@@ -130,8 +132,8 @@
  *
  */
-void ContinuousValueTest::settergetterValueTest()
-{
-  // create instance
-  ContinuousValue<int> test(*ValidRange);
+void ContinuousValueTest::settergetterIntValueTest()
+{
+  // create instance
+  ContinuousValue<int> test(*ValidIntRange);
 
   // unset calling of get, throws
@@ -163,8 +165,8 @@
  *
  */
-void ContinuousValueTest::settergetterTest()
-{
-  // create instance
-  ContinuousValue<int> test(*ValidRange);
+void ContinuousValueTest::settergetterIntTest()
+{
+  // create instance
+  ContinuousValue<int> test(*ValidIntRange);
 
   // unset calling of get, throws
@@ -194,10 +196,10 @@
  *
  */
-void ContinuousValueTest::comparatorTest()
-{
-  {
-    // create instance
-    ContinuousValue<int> test(*ValidRange);
-    ContinuousValue<int> instance(*ValidRange);
+void ContinuousValueTest::comparatorIntTest()
+{
+  {
+    // create instance
+    ContinuousValue<int> test(*ValidIntRange);
+    ContinuousValue<int> instance(*ValidIntRange);
     test.setValue(1);
     instance.setValue(1);
@@ -217,7 +219,7 @@
   }
   {
-    ContinuousValue<int> test(*ValidRange);
-    range<int> OtherValidRange(1,5);
-    ContinuousValue<int> instance(OtherValidRange);
+    ContinuousValue<int> test(*ValidIntRange);
+    range<int> OtherValidIntRange(1,5);
+    ContinuousValue<int> instance(OtherValidIntRange);
 
     test.setValue(1);
@@ -238,2 +240,224 @@
   }
 }
+
+
+
+/***************************** vector tests ***********************************/
+
+/** Unit test for isValid.
+ *
+ */
+void ContinuousValueTest::isValidVectorValueTest()
+{
+  // create instance
+  ContinuousValue<Vector> test(*ValidVectorRange);
+
+  // checking valid values
+  CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(Vector(0,1,2)));
+  CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(Vector(9.9,10.9,11.9)));
+  CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(Vector(5,5,5)));
+
+  // checking invalid values
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(-0.1,0.9,1.9)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(10.1,11.1,12.1)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(5,5,-1)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(5,-1,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(-1,5,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(5,5,20)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(5,20,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(20,5,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(0,0,0)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(5,-1,-1)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(-1,5,-1)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(-1,-1,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(5,20,20)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(20,5,20)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(20,20,5)));
+}
+
+/** Unit test for isValid.
+ *
+ */
+void ContinuousValueTest::isValidVectorTest()
+{
+  // create instance
+  ContinuousValue<Vector> test(*ValidVectorRange);
+
+  // checking valid values
+  CPPUNIT_ASSERT_EQUAL(true, test.isValid(Vector(0,1,2)));
+  CPPUNIT_ASSERT_EQUAL(true, test.isValid(Vector(9.9,10.9,11.9)));
+  CPPUNIT_ASSERT_EQUAL(true, test.isValid(Vector(5,5,5)));
+
+  // checking invalid values
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(-0.1,0.9,1.9)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(10.1,11.1,12.1)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(5,5,-1)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(5,-1,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(-1,5,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(5,5,20)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(5,20,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(20,5,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(0,0,0)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(5,-1,-1)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(-1,5,-1)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(-1,-1,5)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(5,20,20)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(20,5,20)));
+  CPPUNIT_ASSERT_EQUAL(false, test.isValid(Vector(20,20,5)));
+}
+
+/** Unit test for setting/getting valid range.
+ *
+ */
+void ContinuousValueTest::setgetValidVectorRangeTest()
+{
+  {
+    // create instance
+    ContinuousValue<Vector> test(*ValidVectorRange);
+
+    // extending range and checking
+    for (int i=15; i<=16;++i)
+      CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(Vector(i,5,5)));
+    test.setValidRange(range<Vector>(Vector(0,1,2),Vector(20,11,12)));
+    for (int i=15; i<=16;++i)
+      CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(Vector(i,5,5)));
+  }
+
+  {
+    // create instance
+    ContinuousValue<Vector> test(*ValidVectorRange);
+
+    // lowering range with set value
+    test.setValue(Vector(4,4,4));
+    CPPUNIT_ASSERT_EQUAL(true, test.ValueSet);
+#ifndef NDEBUG
+    std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+    CPPUNIT_ASSERT_THROW(test.setValidRange(range<Vector>(Vector(1,1,1),Vector(3,3,3))), Assert::AssertionFailure);
+#else
+    test.setValidRange(range<Vector>(Vector(1,1,1),Vector(3,3,3)));
+#endif
+#ifndef NDEBUG
+    // no value is not set
+    std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+    CPPUNIT_ASSERT_THROW(test.get(), Assert::AssertionFailure);
+#endif
+    // value gets invalidated in either case
+    CPPUNIT_ASSERT_EQUAL(false, test.ValueSet);
+  }
+}
+
+/** Unit test for setValue and getValue.
+ *
+ */
+void ContinuousValueTest::settergetterVectorValueTest()
+{
+  // create instance
+  ContinuousValue<Vector> test(*ValidVectorRange);
+
+  // unset calling of get, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.getValue(), Assert::AssertionFailure);
+#endif
+
+  // setting invalid, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.setValue(Vector(5,0,0)), Assert::AssertionFailure);
+#endif
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.setValue(Vector(5,20,5)), Assert::AssertionFailure);
+#endif
+
+  CPPUNIT_ASSERT_EQUAL(false, test.ValueSet);
+  // checking some valid ones
+  for (int i=1; i<=4;++i) {
+    Vector v(i,5,5);
+    test.setValue(v);
+    CPPUNIT_ASSERT_EQUAL(true, test.ValueSet);
+    CPPUNIT_ASSERT_EQUAL(v, test.getValue());
+  }
+}
+
+/** Unit test for setters and getters.
+ *
+ */
+void ContinuousValueTest::settergetterVectorTest()
+{
+  // create instance
+  ContinuousValue<Vector> test(*ValidVectorRange);
+
+  // unset calling of get, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.get(), Assert::AssertionFailure);
+#endif
+
+  // setting invalid, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.set(Vector(5,0,0)), Assert::AssertionFailure);
+#endif
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.set(Vector(5,20,5)), Assert::AssertionFailure);
+#endif
+
+  CPPUNIT_ASSERT_EQUAL(false, test.ValueSet);
+  // checking some valid ones
+  for (int i=1; i<=4;++i) {
+    Vector v(i,5,5);
+    test.set(v);
+    CPPUNIT_ASSERT_EQUAL(true, test.ValueSet);
+    CPPUNIT_ASSERT_EQUAL(v, test.get());
+  }
+}
+
+/** Unit test for comparator.
+ *
+ */
+void ContinuousValueTest::comparatorVectorTest()
+{
+  {
+    // create instance
+    ContinuousValue<Vector> test(*ValidVectorRange);
+    ContinuousValue<Vector> instance(*ValidVectorRange);
+    test.setValue(Vector(5,6,7));
+    instance.setValue(Vector(5,6,7));
+
+    // same value, same range
+    {
+      CPPUNIT_ASSERT(test == instance);
+    }
+
+    // different value, same range
+    {
+      const Vector oldvalue = instance.getValue();
+      instance.setValue(Vector(2,3,4));
+      CPPUNIT_ASSERT(test != instance);
+      instance.setValue(oldvalue);
+    }
+  }
+  {
+    ContinuousValue<Vector> test(*ValidVectorRange);
+    range<Vector> OtherValidVectorRange(Vector(0,1,2), Vector(20,21,22));
+    ContinuousValue<Vector> instance(OtherValidVectorRange);
+
+    test.setValue(Vector(1,2,3));
+    instance.setValue(Vector(1,2,3));
+
+    // same value, same range
+    {
+      CPPUNIT_ASSERT(test != instance);
+    }
+
+    // different value, same range
+    {
+      const Vector oldvalue = instance.getValue();
+      instance.setValue(Vector(2,3,4));
+      CPPUNIT_ASSERT(test != instance);
+      instance.setValue(oldvalue);
+    }
+  }
+}
Index: src/Parameters/unittests/ContinuousValueTest.hpp
===================================================================
--- src/Parameters/unittests/ContinuousValueTest.hpp	(revision 85d89b9a61c8e0abafadf1dd80be697dab94f94b)
+++ src/Parameters/unittests/ContinuousValueTest.hpp	(revision 7d1b6a327479949780b8727cdc38154708663bf5)
@@ -17,15 +17,24 @@
 #include <cppunit/extensions/HelperMacros.h>
 
+#include "LinearAlgebra/Vector.hpp"
+
 template<class T> struct range;
+class Vector;
 
 class ContinuousValueTest :  public CppUnit::TestFixture
 {
   CPPUNIT_TEST_SUITE( ContinuousValueTest ) ;
-  CPPUNIT_TEST ( isValidValueTest );
-  CPPUNIT_TEST ( isValidTest );
-  CPPUNIT_TEST ( setgetValidRangeTest );
-  CPPUNIT_TEST ( settergetterValueTest );
-  CPPUNIT_TEST ( settergetterTest );
-  CPPUNIT_TEST ( comparatorTest );
+  CPPUNIT_TEST ( isValidIntValueTest );
+  CPPUNIT_TEST ( isValidIntTest );
+  CPPUNIT_TEST ( setgetValidIntRangeTest );
+  CPPUNIT_TEST ( settergetterIntValueTest );
+  CPPUNIT_TEST ( settergetterIntTest );
+  CPPUNIT_TEST ( comparatorIntTest );
+  CPPUNIT_TEST ( isValidVectorValueTest );
+  CPPUNIT_TEST ( isValidVectorTest );
+  CPPUNIT_TEST ( setgetValidVectorRangeTest );
+  CPPUNIT_TEST ( settergetterVectorValueTest );
+  CPPUNIT_TEST ( settergetterVectorTest );
+  CPPUNIT_TEST ( comparatorVectorTest );
   CPPUNIT_TEST_SUITE_END();
 
@@ -34,13 +43,21 @@
   void tearDown();
 
-  void isValidValueTest();
-  void isValidTest();
-  void setgetValidRangeTest();
-  void settergetterValueTest();
-  void settergetterTest();
-  void comparatorTest();
+  void isValidIntValueTest();
+  void isValidIntTest();
+  void setgetValidIntRangeTest();
+  void settergetterIntValueTest();
+  void settergetterIntTest();
+  void comparatorIntTest();
+
+  void isValidVectorValueTest();
+  void isValidVectorTest();
+  void setgetValidVectorRangeTest();
+  void settergetterVectorValueTest();
+  void settergetterVectorTest();
+  void comparatorVectorTest();
 
 private:
-  range<int> *ValidRange;
+  range<int> *ValidIntRange;
+  range<Vector> *ValidVectorRange;
 };
 
Index: src/Parameters/unittests/Makefile.am
===================================================================
--- src/Parameters/unittests/Makefile.am	(revision 85d89b9a61c8e0abafadf1dd80be697dab94f94b)
+++ src/Parameters/unittests/Makefile.am	(revision 7d1b6a327479949780b8727cdc38154708663bf5)
@@ -33,7 +33,9 @@
 	../Parameters/ContinuousValue.hpp \
 	../Parameters/ContinuousValue_impl.hpp \
+	../Parameters/Range.hpp \
 	../Parameters/ValueInterface.hpp
 ContinuousValueTest_LDADD = \
-	$(PARAMETERSLIBS)
+	$(PARAMETERSLIBS) \
+	$(top_builddir)/LinearAlgebra/src/LinearAlgebra/libLinearAlgebra.la
  
 ContinuousParameterTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
@@ -48,5 +50,6 @@
 	../Parameters/ValueInterface.hpp
 ContinuousParameterTest_LDADD = \
-	$(PARAMETERSLIBS)
+	$(PARAMETERSLIBS) \
+	$(top_builddir)/LinearAlgebra/src/LinearAlgebra/libLinearAlgebra.la
  
 DiscreteValueTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
