diff --git a/examples/undocumented/libshogun/classifier_bagging_liblinear.cpp b/examples/undocumented/libshogun/classifier_bagging_liblinear.cpp
index 97dc6802396..5e669d30167 100644
--- a/examples/undocumented/libshogun/classifier_bagging_liblinear.cpp
+++ b/examples/undocumented/libshogun/classifier_bagging_liblinear.cpp
@@ -33,7 +33,7 @@ int main(int argc, char** argv)
 	CFeatures* neg = gen_n->get_streamed_features(num_pos);
 	CFeatures* pos = gen_p->get_streamed_features(num_neg);
 	CDenseFeatures<float64_t>* train_feats =
-		CDenseFeatures<float64_t>::obtain_from_generic(neg->create_merged_copy(pos));
+		neg->create_merged_copy(pos)->as<CDenseFeatures<float64_t>>();
 
 	SGVector<float64_t> tl(num_neg+num_pos);
 	tl.set_const(1);
diff --git a/examples/undocumented/libshogun/minibatchKMeans.cpp b/examples/undocumented/libshogun/minibatchKMeans.cpp
index 2d6c53fbb9c..9c983cb8c0c 100644
--- a/examples/undocumented/libshogun/minibatchKMeans.cpp
+++ b/examples/undocumented/libshogun/minibatchKMeans.cpp
@@ -44,7 +44,7 @@ int main(int argc, char **argv)
 	for (index_t i=0; i<result->get_num_labels(); ++i)
 		SG_SPRINT("cluster index of vector %i: %f\n", i, result->get_label(i));
 
-	CDenseFeatures<float64_t>* centers=CDenseFeatures<float64_t>::obtain_from_generic(distance->get_lhs());
+	CDenseFeatures<float64_t>* centers=distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 	SGMatrix<float64_t> centers_matrix=centers->get_feature_matrix();
 	centers_matrix.display_matrix(centers_matrix.matrix,
 			centers_matrix.num_rows, centers_matrix.num_cols, "learnt centers using Lloyd's KMeans");
diff --git a/src/shogun/clustering/KMeans.cpp b/src/shogun/clustering/KMeans.cpp
index 59b92a5d3a5..525e89d3cf2 100644
--- a/src/shogun/clustering/KMeans.cpp
+++ b/src/shogun/clustering/KMeans.cpp
@@ -1,8 +1,8 @@
 /*
  * This software is distributed under BSD 3-clause license (see LICENSE file).
  *
- * Authors: Heiko Strathmann, Soeren Sonnenburg, Saurabh Mahindre, 
- *          Sergey Lisitsyn, Evan Shelhamer, Soumyajit De, Fernando Iglesias, 
+ * Authors: Heiko Strathmann, Soeren Sonnenburg, Saurabh Mahindre,
+ *          Sergey Lisitsyn, Evan Shelhamer, Soumyajit De, Fernando Iglesias,
  *          Björn Esser, parijat
  */
 
@@ -39,8 +39,8 @@ CKMeans::~CKMeans()
 
 void CKMeans::Lloyd_KMeans(SGMatrix<float64_t> centers, int32_t num_centers)
 {
-	CDenseFeatures<float64_t>* lhs=
-		CDenseFeatures<float64_t>::obtain_from_generic(distance->get_lhs());
+	CDenseFeatures<float64_t>* lhs =
+		distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 
 	int32_t lhs_size=lhs->get_num_vectors();
 	int32_t dim=lhs->get_num_features();
diff --git a/src/shogun/clustering/KMeansBase.cpp b/src/shogun/clustering/KMeansBase.cpp
index 9f34fcedd0a..b7fd2c2c4b4 100644
--- a/src/shogun/clustering/KMeansBase.cpp
+++ b/src/shogun/clustering/KMeansBase.cpp
@@ -46,7 +46,7 @@ CKMeansBase::~CKMeansBase()
 
 void CKMeansBase::set_initial_centers(SGMatrix<float64_t> centers)
 {
- 	CDenseFeatures<float64_t>* lhs=((CDenseFeatures<float64_t>*) distance->get_lhs());
+	CDenseFeatures<float64_t>* lhs=distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 	dimensions=lhs->get_num_features();
 	REQUIRE(centers.num_cols == k,
 			"Expected %d initial cluster centers, got %d", k, centers.num_cols);
@@ -60,9 +60,9 @@ void CKMeansBase::set_random_centers()
 {
 	mus.zero();
 	CDenseFeatures<float64_t>* lhs=
-		CDenseFeatures<float64_t>::obtain_from_generic(distance->get_lhs());
+		distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 	int32_t lhs_size=lhs->get_num_vectors();
-	
+
 	SGVector<int32_t> temp=SGVector<int32_t>(lhs_size);
 	SGVector<int32_t>::range_fill_vector(temp, lhs_size, 0);
 	CMath::permute(temp);
@@ -134,12 +134,12 @@ void CKMeansBase::initialize_training(CFeatures* data)
 {
 	REQUIRE(distance, "Distance is not provided")
 	REQUIRE(distance->get_feature_type()==F_DREAL, "Distance's features type (%d) should be of type REAL (%d)")
-	
+
 	if (data)
 		distance->init(data, data);
 
 	CDenseFeatures<float64_t>* lhs=
-		CDenseFeatures<float64_t>::obtain_from_generic(distance->get_lhs());
+		distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 
 	REQUIRE(lhs, "Lhs features of distance not provided");
 	int32_t lhs_size=lhs->get_num_vectors();
@@ -225,7 +225,7 @@ SGMatrix<float64_t> CKMeansBase::get_cluster_centers()
 		return SGMatrix<float64_t>();
 
 	CDenseFeatures<float64_t>* lhs=
-		(CDenseFeatures<float64_t>*)distance->get_lhs();
+		distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 	SGMatrix<float64_t> centers=lhs->get_feature_matrix();
 	SG_UNREF(lhs);
 	return centers;
@@ -261,9 +261,9 @@ void CKMeansBase::store_model_features()
 SGMatrix<float64_t> CKMeansBase::kmeanspp()
 {
 	int32_t lhs_size;
-	CDenseFeatures<float64_t>* lhs=(CDenseFeatures<float64_t>*)distance->get_lhs();
+	CDenseFeatures<float64_t>* lhs=distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 	lhs_size=lhs->get_num_vectors();
-	
+
 	SGMatrix<float64_t> centers=SGMatrix<float64_t>(dimensions, k);
 	centers.zero();
 	SGVector<float64_t> min_dist=SGVector<float64_t>(lhs_size);
@@ -271,7 +271,7 @@ SGMatrix<float64_t> CKMeansBase::kmeanspp()
 
 	/* First center is chosen at random */
 	int32_t mu=CMath::random((int32_t) 0, lhs_size-1);
-	SGVector<float64_t> mu_first=lhs->get_feature_vector(mu);	
+	SGVector<float64_t> mu_first=lhs->get_feature_vector(mu);
 	for(int32_t j=0; j<dimensions; j++)
 		centers(j, 0)=mu_first[j];
 
@@ -292,21 +292,21 @@ SGMatrix<float64_t> CKMeansBase::kmeanspp()
 
 	/* Choose centers with weighted probability */
 	for(int32_t i=1; i<k; i++)
-	{	
-		int32_t best_center=0;		
+	{
+		int32_t best_center=0;
 		float64_t best_sum=-1.0;
 		SGVector<float64_t> best_min_dist=SGVector<float64_t>(lhs_size);
 
 		/* local tries for best center */
 		for(int32_t trial=0; trial<n_rands; trial++)
 		{
-			float64_t temp_sum=0.0;		
+			float64_t temp_sum=0.0;
 			float64_t temp_dist=0.0;
-			SGVector<float64_t> temp_min_dist=SGVector<float64_t>(lhs_size);		
-			int32_t new_center=0;		
+			SGVector<float64_t> temp_min_dist=SGVector<float64_t>(lhs_size);
+			int32_t new_center=0;
 			float64_t prob=CMath::random(0.0, 1.0);
 			prob=prob*sum;
-		
+
 			for(int32_t j=0; j<lhs_size; j++)
 			{
 				temp_sum+=min_dist[j];
@@ -339,7 +339,7 @@ SGMatrix<float64_t> CKMeansBase::kmeanspp()
 				best_center=new_center;
 			}
 		}
-		
+
 		SGVector<float64_t> vec=lhs->get_feature_vector(best_center);
 		for(int32_t j=0; j<dimensions; j++)
 			centers(j, i)=vec[j];
diff --git a/src/shogun/clustering/KMeansMiniBatch.cpp b/src/shogun/clustering/KMeansMiniBatch.cpp
index cf4be12da42..29d0628465d 100644
--- a/src/shogun/clustering/KMeansMiniBatch.cpp
+++ b/src/shogun/clustering/KMeansMiniBatch.cpp
@@ -75,7 +75,7 @@ void CKMeansMiniBatch::minibatch_KMeans()
 		"number of iterations not set to positive value. Current iterations %d \n", minib_iter);
 
 	CDenseFeatures<float64_t>* lhs=
-		CDenseFeatures<float64_t>::obtain_from_generic(distance->get_lhs());
+		distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 	CDenseFeatures<float64_t>* rhs_mus=new CDenseFeatures<float64_t>(mus);
 	CFeatures* rhs_cache=distance->replace_rhs(rhs_mus);
 	int32_t XSize=lhs->get_num_vectors();
diff --git a/src/shogun/distributions/KernelDensity.cpp b/src/shogun/distributions/KernelDensity.cpp
index 751b7b332f5..f9bab0d8c1d 100644
--- a/src/shogun/distributions/KernelDensity.cpp
+++ b/src/shogun/distributions/KernelDensity.cpp
@@ -57,7 +57,7 @@ CKernelDensity::~CKernelDensity()
 bool CKernelDensity::train(CFeatures* data)
 {
 	REQUIRE(data,"Data not supplied\n")
-	CDenseFeatures<float64_t>* dense_data=CDenseFeatures<float64_t>::obtain_from_generic(data);
+	CDenseFeatures<float64_t>* dense_data=data->as<CDenseFeatures<float64_t>>();
 
 	SG_UNREF(tree);
 	switch (m_eval)
diff --git a/src/shogun/features/CombinedDotFeatures.h b/src/shogun/features/CombinedDotFeatures.h
index 77684089ca2..249d6733287 100644
--- a/src/shogun/features/CombinedDotFeatures.h
+++ b/src/shogun/features/CombinedDotFeatures.h
@@ -1,8 +1,8 @@
 /*
  * This software is distributed under BSD 3-clause license (see LICENSE file).
  *
- * Authors: Soeren Sonnenburg, Sergey Lisitsyn, Heiko Strathmann, 
- *          Vladislav Horbatiuk, Evgeniy Andreev, Yuyu Zhang, Evan Shelhamer, 
+ * Authors: Soeren Sonnenburg, Sergey Lisitsyn, Heiko Strathmann,
+ *          Vladislav Horbatiuk, Evgeniy Andreev, Yuyu Zhang, Evan Shelhamer,
  *          Björn Esser, Evangelos Anagnostopoulos
  */
 
diff --git a/src/shogun/features/DenseFeatures.cpp b/src/shogun/features/DenseFeatures.cpp
index 2ce0e63aa1c..9cdfc042f33 100644
--- a/src/shogun/features/DenseFeatures.cpp
+++ b/src/shogun/features/DenseFeatures.cpp
@@ -1,10 +1,10 @@
 /*
  * This software is distributed under BSD 3-clause license (see LICENSE file).
  *
- * Authors: Soeren Sonnenburg, Saurabh Mahindre, Soumyajit De, Heiko Strathmann, 
- *          Sergey Lisitsyn, Sanuj Sharma, Chiyuan Zhang, Viktor Gal, 
- *          Michele Mazzoni, Vladislav Horbatiuk, Kevin Hughes, Weijie Lin, 
- *          Fernando Iglesias, Björn Esser, Evgeniy Andreev, 
+ * Authors: Soeren Sonnenburg, Saurabh Mahindre, Soumyajit De, Heiko Strathmann,
+ *          Sergey Lisitsyn, Sanuj Sharma, Chiyuan Zhang, Viktor Gal,
+ *          Michele Mazzoni, Vladislav Horbatiuk, Kevin Hughes, Weijie Lin,
+ *          Fernando Iglesias, Björn Esser, Evgeniy Andreev,
  *          Christopher Goldsworthy
  */
 
@@ -61,6 +61,28 @@ template<class ST> CDenseFeatures<ST>::CDenseFeatures(CFile* loader) :
 	load(loader);
 }
 
+template<class ST> CDenseFeatures<ST>::CDenseFeatures(CDotFeatures* features) :
+		CDotFeatures()
+{
+	init();
+
+	auto num_feat = features->get_dim_feature_space();
+	auto num_vec = features->get_num_vectors();
+
+	ASSERT(num_feat>0 && num_vec>0)
+	feature_matrix = SGMatrix<ST>(num_feat, num_vec);
+	for (auto i = 0; i < num_vec; i++)
+	{
+		SGVector<float64_t> v = features->get_computed_dot_feature_vector(i);
+		ASSERT(num_feat==v.vlen)
+
+		for (auto j = 0; j < num_feat; j++)
+			feature_matrix.matrix[i * int64_t(num_feat) + j] = (ST) v.vector[j];
+	}
+	num_features = num_feat;
+	num_vectors = num_vec;
+}
+
 template<class ST> CFeatures* CDenseFeatures<ST>::duplicate() const
 {
 	return new CDenseFeatures<ST>(*this);
@@ -366,30 +388,6 @@ template<class ST> ST* CDenseFeatures<ST>::get_transposed(int32_t &num_feat, int
 	return fm;
 }
 
-template<class ST> void CDenseFeatures<ST>::obtain_from_dot(CDotFeatures* df)
-{
-	m_subset_stack->remove_all_subsets();
-
-	int32_t num_feat = df->get_dim_feature_space();
-	int32_t num_vec = df->get_num_vectors();
-
-	ASSERT(num_feat>0 && num_vec>0)
-
-	free_feature_matrix();
-	feature_matrix = SGMatrix<ST>(num_feat, num_vec);
-
-	for (int32_t i = 0; i < num_vec; i++)
-	{
-		SGVector<float64_t> v = df->get_computed_dot_feature_vector(i);
-		ASSERT(num_feat==v.vlen)
-
-		for (int32_t j = 0; j < num_feat; j++)
-			feature_matrix.matrix[i * int64_t(num_feat) + j] = (ST) v.vector[j];
-	}
-	num_features = num_feat;
-	num_vectors = num_vec;
-}
-
 template<class ST> bool CDenseFeatures<ST>::apply_preprocessor(bool force_preprocessing)
 {
 	if (m_subset_stack->has_subsets())
@@ -468,8 +466,6 @@ template<class ST> void CDenseFeatures<ST>::initialize_cache()
 	}
 }
 
-template<class ST> EFeatureClass CDenseFeatures<ST>::get_feature_class() const  { return C_DENSE; }
-
 template<class ST> bool CDenseFeatures<ST>::reshape(int32_t p_num_features, int32_t p_num_vectors)
 {
 	if (m_subset_stack->has_subsets())
@@ -1082,14 +1078,6 @@ void CDenseFeatures<ST>::save(CFile* writer)
 	feature_matrix.save(writer);
 }
 
-template< class ST > CDenseFeatures< ST >* CDenseFeatures< ST >::obtain_from_generic(CFeatures* const base_features)
-{
-	REQUIRE(base_features->get_feature_class() == C_DENSE,
-			"base_features must be of dynamic type CDenseFeatures\n")
-
-	return (CDenseFeatures< ST >*) base_features;
-}
-
 template class CDenseFeatures<bool>;
 template class CDenseFeatures<char>;
 template class CDenseFeatures<int8_t>;
diff --git a/src/shogun/features/DenseFeatures.h b/src/shogun/features/DenseFeatures.h
index 65c99dbadf9..c9b0d6eb5c7 100644
--- a/src/shogun/features/DenseFeatures.h
+++ b/src/shogun/features/DenseFeatures.h
@@ -1,8 +1,8 @@
 /*
  * This software is distributed under BSD 3-clause license (see LICENSE file).
  *
- * Authors: Soumyajit De, Heiko Strathmann, Saurabh Mahindre, Soeren Sonnenburg, 
- *          Vladislav Horbatiuk, Yuyu Zhang, Kevin Hughes, Evgeniy Andreev, 
+ * Authors: Soumyajit De, Heiko Strathmann, Saurabh Mahindre, Soeren Sonnenburg,
+ *          Vladislav Horbatiuk, Yuyu Zhang, Kevin Hughes, Evgeniy Andreev,
  *          Thoralf Klein, Fernando Iglesias, Björn Esser, Sergey Lisitsyn
  */
 
@@ -87,6 +87,12 @@ template<class ST> class CDenseFeatures: public CDotFeatures
 	 */
 	CDenseFeatures(ST* src, int32_t num_feat, int32_t num_vec);
 
+	/** constructor from DotFeatures
+	 *
+	 * @param features DotFeatures object
+	 */
+	CDenseFeatures(CDotFeatures* features);
+
 	/** constructor loading features from file
 	 *
 	 * @param loader File object via which to load data
@@ -255,14 +261,6 @@ template<class ST> class CDenseFeatures: public CDotFeatures
 	 */
 	ST* get_transposed(int32_t &num_feat, int32_t &num_vec);
 
-	/** obtain dense features from other dotfeatures
-	 *
-	 * removes any subset before
-	 *
-	 * @param df dotfeatures to obtain features from
-	 */
-	void obtain_from_dot(CDotFeatures* df);
-
 	/** apply preprocessor
 	 *
 	 * applies preprocessors to ALL features (subset removed before and
@@ -495,11 +493,6 @@ template<class ST> class CDenseFeatures: public CDotFeatures
 	 */
 	CFeatures* create_merged_copy(CFeatures* other);
 
-	/** helper method used to specialize a base class instance
-	 *
-	 */
-	static CDenseFeatures* obtain_from_generic(CFeatures* const base_features);
-
 #ifndef SWIG // SWIG should skip this part
 	virtual CFeatures* shallow_subset_copy();
 #endif
diff --git a/src/shogun/features/Features.h b/src/shogun/features/Features.h
index fb86af592cc..e2adcbd6a69 100644
--- a/src/shogun/features/Features.h
+++ b/src/shogun/features/Features.h
@@ -1,8 +1,8 @@
 /*
  * This software is distributed under BSD 3-clause license (see LICENSE file).
  *
- * Authors: Heiko Strathmann, Soeren Sonnenburg, Sergey Lisitsyn, 
- *          Saurabh Mahindre, Evgeniy Andreev, Wu Lin, Vladislav Horbatiuk, 
+ * Authors: Heiko Strathmann, Soeren Sonnenburg, Sergey Lisitsyn,
+ *          Saurabh Mahindre, Evgeniy Andreev, Wu Lin, Vladislav Horbatiuk,
  *          Yuyu Zhang, Björn Esser, Soumyajit De
  */
 
@@ -335,19 +335,47 @@ class CFeatures : public CSGObject
 		 */
 		virtual bool support_compatible_class() const {return false;}
 
-		/** Given a class in right hand side, does this class support compatible computation? 
+		/** Given a class in right hand side, does this class support compatible computation?
 		 *
 		 * for example, is this->dot(rhs_prt) valid,
-		 * where rhs_prt is the class in right hand side 
+		 * where rhs_prt is the class in right hand side
 		 *
-		 * @param rhs the class in right hand side 
+		 * @param rhs the class in right hand side
 		 * @return whether this class supports compatible computation
 		 */
 		virtual bool get_feature_class_compatibility (EFeatureClass rhs) const;
 
 #ifndef SWIG // SWIG should skip this part
-		virtual CFeatures* shallow_subset_copy() 
-		{ 
+		/**
+		 * Utility method to specialize the feature to the required type.
+		 *
+		 * @param f CFeatures base type
+		 * @return The requested type if casting was successful.
+		 */
+		template<class T> static T* as(CFeatures* f)
+		{
+			REQUIRE(f, "Features is null!\n");
+			return f->as<T>();
+		}
+
+		/**
+		 * Utility method to specialize the feature to the required type.
+		 *
+		 * @param f CFeatures base type
+		 * @return The requested type if casting was successful.
+		 */
+		template<class T> T* as()
+		{
+			if (typeid(T) != typeid(*this))
+			{
+				SG_SERROR("Provided features (%s) is not of requested type %s!\n",
+					typeid(*this).name(), typeid(T).name());
+			}
+			return (T*)this;
+		}
+
+		virtual CFeatures* shallow_subset_copy()
+		{
 			SG_SNOTIMPLEMENTED;
 			return NULL;
 		}
diff --git a/src/shogun/features/SparseFeatures.cpp b/src/shogun/features/SparseFeatures.cpp
index 7aa9f7d5eae..4683f2a8fd4 100644
--- a/src/shogun/features/SparseFeatures.cpp
+++ b/src/shogun/features/SparseFeatures.cpp
@@ -44,6 +44,21 @@ template<class ST> CSparseFeatures<ST>::CSparseFeatures(const CSparseFeatures &
 	m_subset_stack=orig.m_subset_stack;
 	SG_REF(m_subset_stack);
 }
+
+template<class ST> CSparseFeatures<ST>::CSparseFeatures(CDenseFeatures<ST>* dense)
+{
+	init();
+
+	SGMatrix<ST> fm=dense->get_feature_matrix();
+	ASSERT(fm.matrix && fm.num_cols>0 && fm.num_rows>0)
+	set_full_feature_matrix(fm);
+}
+
+template<> CSparseFeatures<complex128_t>::CSparseFeatures(CDenseFeatures<complex128_t>* dense)
+{
+	SG_NOTIMPLEMENTED;
+}
+
 template<class ST> CSparseFeatures<ST>::CSparseFeatures(CFile* loader)
 : CDotFeatures(), feature_cache(NULL)
 {
@@ -316,18 +331,6 @@ template<class ST> bool CSparseFeatures<ST>::apply_preprocessor(bool force_prepr
 	}
 }
 
-template<class ST> void CSparseFeatures<ST>::obtain_from_simple(CDenseFeatures<ST>* sf)
-{
-	SGMatrix<ST> fm=sf->get_feature_matrix();
-	ASSERT(fm.matrix && fm.num_cols>0 && fm.num_rows>0)
-	set_full_feature_matrix(fm);
-}
-
-template<> void CSparseFeatures<complex128_t>::obtain_from_simple(CDenseFeatures<complex128_t>* sf)
-{
-	SG_NOTIMPLEMENTED;
-}
-
 template<class ST> int32_t  CSparseFeatures<ST>::get_num_vectors() const
 {
 	return m_subset_stack->has_subsets() ? m_subset_stack->get_size() : sparse_feature_matrix.num_vectors;
diff --git a/src/shogun/features/SparseFeatures.h b/src/shogun/features/SparseFeatures.h
index 6c8d356c06b..cbb5970f671 100644
--- a/src/shogun/features/SparseFeatures.h
+++ b/src/shogun/features/SparseFeatures.h
@@ -1,8 +1,8 @@
 /*
  * This software is distributed under BSD 3-clause license (see LICENSE file).
  *
- * Authors: Heiko Strathmann, Soeren Sonnenburg, Sergey Lisitsyn, 
- *          Evgeniy Andreev, Vladislav Horbatiuk, Yuyu Zhang, Viktor Gal, 
+ * Authors: Heiko Strathmann, Soeren Sonnenburg, Sergey Lisitsyn,
+ *          Evgeniy Andreev, Vladislav Horbatiuk, Yuyu Zhang, Viktor Gal,
  *          Thoralf Klein, Björn Esser, Soumyajit De
  */
 
@@ -72,6 +72,9 @@ template <class ST> class CSparseFeatures : public CDotFeatures
 		/** copy constructor */
 		CSparseFeatures(const CSparseFeatures & orig);
 
+		/** copy constructor from DenseFeatures */
+		CSparseFeatures(CDenseFeatures<ST>* dense);
+
 		/** constructor loading features from file
 		 *
 		 * @param loader File object to load data from
@@ -249,14 +252,6 @@ template <class ST> class CSparseFeatures : public CDotFeatures
 		 */
 		virtual bool apply_preprocessor(bool force_preprocessing=false);
 
-		/** obtain sparse features from simple features
-		 *
-		 * subset on input is ignored, subset of this instance is removed
-		 *
-		 * @param sf simple features
-		 */
-		void obtain_from_simple(CDenseFeatures<ST>* sf);
-
 		/** get number of feature vectors, possibly of subset
 		 *
 		 * @return number of feature vectors
diff --git a/src/shogun/machine/StochasticGBMachine.cpp b/src/shogun/machine/StochasticGBMachine.cpp
index fc14fd16f3b..5b5e29668a8 100644
--- a/src/shogun/machine/StochasticGBMachine.cpp
+++ b/src/shogun/machine/StochasticGBMachine.cpp
@@ -142,7 +142,7 @@ float64_t CStochasticGBMachine::get_learning_rate() const
 CRegressionLabels* CStochasticGBMachine::apply_regression(CFeatures* data)
 {
 	REQUIRE(data,"test data supplied is NULL\n")
-	CDenseFeatures<float64_t>* feats=CDenseFeatures<float64_t>::obtain_from_generic(data);
+	CDenseFeatures<float64_t>* feats=data->as<CDenseFeatures<float64_t>>();
 
 	SGVector<float64_t> retlabs(feats->get_num_vectors());
 	retlabs.fill_vector(retlabs.vector,retlabs.vlen,0);
@@ -173,7 +173,7 @@ bool CStochasticGBMachine::train_machine(CFeatures* data)
 	REQUIRE(m_machine,"machine not set!\n")
 	REQUIRE(m_loss,"loss function not specified\n")
 
-	CDenseFeatures<float64_t>* feats=CDenseFeatures<float64_t>::obtain_from_generic(data);
+	CDenseFeatures<float64_t>* feats=data->as<CDenseFeatures<float64_t>>();
 
 	// initialize weak learners array and gamma array
 	initialize_learners();
diff --git a/src/shogun/multiclass/tree/CHAIDTree.cpp b/src/shogun/multiclass/tree/CHAIDTree.cpp
index 3c7f58afc0d..1a87e167291 100644
--- a/src/shogun/multiclass/tree/CHAIDTree.cpp
+++ b/src/shogun/multiclass/tree/CHAIDTree.cpp
@@ -154,9 +154,8 @@ void CCHAIDTree::set_dependent_vartype(int32_t var)
 bool CCHAIDTree::train_machine(CFeatures* data)
 {
 	REQUIRE(data, "Data required for training\n")
-	REQUIRE(data->get_feature_class()==C_DENSE,"Dense data required for training\n")
 
-	CDenseFeatures<float64_t>* feats=CDenseFeatures<float64_t>::obtain_from_generic(data);
+	CDenseFeatures<float64_t>* feats=data->as<CDenseFeatures<float64_t>>();
 
 	REQUIRE(m_feature_types.vlen==feats->get_num_features(),"Either feature types are not set or the number of feature types specified"
 	" (%d here) is not the same as the number of features in data matrix (%d here)\n",m_feature_types.vlen,feats->get_num_features())
@@ -204,7 +203,7 @@ CTreeMachineNode<CHAIDTreeNodeData>* CCHAIDTree::CHAIDtrain(CFeatures* data, SGV
 
 	node_t* node=new node_t();
 	SGVector<float64_t> labels_vec=(dynamic_cast<CDenseLabels*>(labels))->get_labels();
-	SGMatrix<float64_t> mat=(CDenseFeatures<float64_t>::obtain_from_generic(data))->get_feature_matrix();
+	SGMatrix<float64_t> mat=data->as<CDenseFeatures<float64_t>>->get_feature_matrix();
 	int32_t num_feats=mat.num_rows;
 	int32_t num_vecs=mat.num_cols;
 
@@ -665,7 +664,7 @@ SGVector<int32_t> CCHAIDTree::merge_categories_nominal(SGVector<float64_t> feats
 
 CLabels* CCHAIDTree::apply_tree(CFeatures* data)
 {
-	CDenseFeatures<float64_t>* feats=CDenseFeatures<float64_t>::obtain_from_generic(data);
+	CDenseFeatures<float64_t>* feats=data->as<CDenseFeatures<float64_t>>();
 
 	// modify test data matrix (continuous to ordinal)
 	if (m_cont_breakpoints.num_cols>0)
diff --git a/src/shogun/preprocessor/DimensionReductionPreprocessor.cpp b/src/shogun/preprocessor/DimensionReductionPreprocessor.cpp
index 38213526003..dd70212d5c6 100644
--- a/src/shogun/preprocessor/DimensionReductionPreprocessor.cpp
+++ b/src/shogun/preprocessor/DimensionReductionPreprocessor.cpp
@@ -51,7 +51,7 @@ SGMatrix<float64_t> CDimensionReductionPreprocessor::apply_to_feature_matrix(CFe
 	else
 	{
 		SG_WARNING("Converter to process was not set.\n")
-		return ((CDenseFeatures<float64_t>*)features)->get_feature_matrix();
+		return features->as<CDenseFeatures<float64_t>>()->get_feature_matrix();
 	}
 }
 
diff --git a/src/shogun/preprocessor/PCA.cpp b/src/shogun/preprocessor/PCA.cpp
index bc934f6d234..0dc36853277 100644
--- a/src/shogun/preprocessor/PCA.cpp
+++ b/src/shogun/preprocessor/PCA.cpp
@@ -1,7 +1,7 @@
 /*
  * This software is distributed under BSD 3-clause license (see LICENSE file).
  *
- * Authors: Soeren Sonnenburg, Sergey Lisitsyn, Heiko Strathmann, Viktor Gal, 
+ * Authors: Soeren Sonnenburg, Sergey Lisitsyn, Heiko Strathmann, Viktor Gal,
  *          Evan Shelhamer, Evgeniy Andreev, Marc Zimmermann, Björn Esser
  */
 #include <shogun/lib/config.h>
@@ -287,7 +287,7 @@ SGMatrix<float64_t> CPCA::apply_to_feature_matrix(CFeatures* features)
 {
 	ASSERT(m_initialized)
 	ASSERT(features != NULL)
-	SGMatrix<float64_t> m = ((CDenseFeatures<float64_t>*) features)->get_feature_matrix();
+	SGMatrix<float64_t> m = features->as<CDenseFeatures<float64_t>>()->get_feature_matrix();
 	int32_t num_vectors = m.num_cols;
 	int32_t num_features = m.num_rows;
 
diff --git a/tests/unit/clustering/kmeans_unittest.cc b/tests/unit/clustering/kmeans_unittest.cc
index 41602655d04..f76327095fa 100644
--- a/tests/unit/clustering/kmeans_unittest.cc
+++ b/tests/unit/clustering/kmeans_unittest.cc
@@ -37,7 +37,7 @@ TEST(KMeans, manual_center_initialization_test)
 	initial_centers(1,1)=5;
 
 	CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(rect);
-	SG_REF(features);	
+	SG_REF(features);
 	CEuclideanDistance* distance=new CEuclideanDistance(features, features);
 	CKMeans* clustering=new CKMeans(2, distance,initial_centers);
 
@@ -52,7 +52,7 @@ TEST(KMeans, manual_center_initialization_test)
 		EXPECT_EQ(1.000000, result->get_label(2));
 		EXPECT_EQ(1.000000, result->get_label(3));
 
-		CDenseFeatures<float64_t>* learnt_centers=CDenseFeatures<float64_t>::obtain_from_generic(distance->get_lhs());
+		CDenseFeatures<float64_t>* learnt_centers=distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 		SGMatrix<float64_t> learnt_centers_matrix=learnt_centers->get_feature_matrix();
 
 		EXPECT_EQ(0, learnt_centers_matrix(0,0));
@@ -89,7 +89,7 @@ TEST(KMeans, KMeanspp_center_initialization_test)
 	for (int32_t loop=0; loop<10; loop++)
 	{
 		clustering->train(features);
-		CDenseFeatures<float64_t>* learnt_centers=CDenseFeatures<float64_t>::obtain_from_generic(distance->get_lhs());
+		CDenseFeatures<float64_t>* learnt_centers=distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 		SGMatrix<float64_t> learnt_centers_matrix=learnt_centers->get_feature_matrix();
 		SGVector<int32_t> count=SGVector<int32_t>(4);
 		count.zero();
@@ -143,7 +143,7 @@ TEST(KMeans, minibatch_training_test)
 	initial_centers(1,0)=0;
 
 	CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(rect);
-	SG_REF(features);	
+	SG_REF(features);
 	CEuclideanDistance* distance=new CEuclideanDistance(features, features);
 	CKMeansMiniBatch* clustering=new CKMeansMiniBatch(1, distance,initial_centers);
 
@@ -151,7 +151,7 @@ TEST(KMeans, minibatch_training_test)
 	{
 		clustering->set_mb_params(4,1000);
 		clustering->train(features);
-		CDenseFeatures<float64_t>* learnt_centers=CDenseFeatures<float64_t>::obtain_from_generic(distance->get_lhs());
+		CDenseFeatures<float64_t>* learnt_centers=distance->get_lhs()->as<CDenseFeatures<float64_t>>();
 		SGMatrix<float64_t> learnt_centers_matrix=learnt_centers->get_feature_matrix();
 
 		EXPECT_NEAR(1, learnt_centers_matrix(0,0), 0.0001);
@@ -185,7 +185,7 @@ TEST(KMeans, fixed_centers)
 	initial_centers(1,1)=4;
 
 	CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(rect);
-	SG_REF(features);	
+	SG_REF(features);
 	CEuclideanDistance* distance=new CEuclideanDistance(features, features);
 	CKMeans* clustering=new CKMeans(2, distance,initial_centers);
 	clustering->set_fixed_centers(true);
@@ -195,12 +195,12 @@ TEST(KMeans, fixed_centers)
 
 	ASSERT_NE(learnt_centers, (CDenseFeatures<float64_t>*)NULL);
 	SGMatrix<float64_t> c=learnt_centers->get_feature_matrix();
-		
+
 	EXPECT_NEAR(c(0,0), 0.0, 10E-12);
 	EXPECT_NEAR(c(1,0), 5.0, 10E-12);
 	EXPECT_NEAR(c(0,1), 20.0, 10E-12);
 	EXPECT_NEAR(c(1,1), 5.0, 10E-12);
-	
+
 	SG_UNREF(clustering);
 	SG_UNREF(features);
 	SG_UNREF(learnt_centers);
@@ -218,7 +218,7 @@ TEST(KMeans, random_centers_init)
 	rect(1,2)=20;
 
 	CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(rect);
-	SG_REF(features);	
+	SG_REF(features);
 	CEuclideanDistance* distance=new CEuclideanDistance(features, features);
 	CKMeans* clustering=new CKMeans(3, distance);
 
@@ -226,11 +226,11 @@ TEST(KMeans, random_centers_init)
 	CDenseFeatures<float64_t>* learnt_centers=(CDenseFeatures<float64_t>*)distance->get_lhs();
 	ASSERT_NE(learnt_centers, (CDenseFeatures<float64_t>*)NULL);
 	SGMatrix<float64_t> c=learnt_centers->get_feature_matrix();
-		
+
 	EXPECT_NE(c(0,0),c(0,1));
 	EXPECT_NE(c(0,0),c(0,2));
 	EXPECT_NE(c(0,1),c(0,2));
-	
+
 	SG_UNREF(clustering);
 	SG_UNREF(features);
 	SG_UNREF(learnt_centers);
@@ -250,15 +250,15 @@ TEST(KMeans, random_centers_assign)
 	rect(1,3)=10;
 
 	CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(rect);
-	SG_REF(features);	
+	SG_REF(features);
 	CEuclideanDistance* distance=new CEuclideanDistance(features, features);
 	CKMeans* clustering=new CKMeans(2, distance);
 
 	clustering->train(features);
 	CDenseFeatures<float64_t>* learnt_centers=(CDenseFeatures<float64_t>*)distance->get_lhs();
-	ASSERT_NE(learnt_centers, (CDenseFeatures<float64_t>*)NULL);	
+	ASSERT_NE(learnt_centers, (CDenseFeatures<float64_t>*)NULL);
 	SGMatrix<float64_t> c=learnt_centers->get_feature_matrix();
-	
+
 	SGVector<float64_t> count=SGVector<float64_t>(2);
 	count.zero();
 
@@ -269,13 +269,13 @@ TEST(KMeans, random_centers_assign)
 	if ((c(0,0)==20) && (c(1,0)==5))
 		count[1]++;
 	if ((c(0,1)==20) && (c(1,1)==5))
-		count[1]++;	
+		count[1]++;
 
 	if (count[0] == 0)
 		EXPECT_EQ(count[1], 0);
 	if (count[0] == 1)
 		EXPECT_EQ(count[1], 1);
-	
+
 	SG_UNREF(clustering);
 	SG_UNREF(features);
 	SG_UNREF(learnt_centers);