diff --git a/src/shogun/kernel/ExponentialARDKernel.cpp b/src/shogun/kernel/ExponentialARDKernel.cpp
index a0064395c08..e3f7d5fa631 100644
--- a/src/shogun/kernel/ExponentialARDKernel.cpp
+++ b/src/shogun/kernel/ExponentialARDKernel.cpp
@@ -244,7 +244,7 @@ SGMatrix<float64_t> CExponentialARDKernel::get_weighted_vector(SGVector<float64_
 			{
 			return CMath::exp(value);
 			});
-		res=linalg::elementwise_product(weights, rtmp);
+		res=linalg::element_prod(weights, rtmp);
 	}
 	return res;
 }
diff --git a/src/shogun/lib/GPUMatrix.h b/src/shogun/lib/GPUMatrix.h
index 3cc1f24cf33..f5d6e5deb4c 100644
--- a/src/shogun/lib/GPUMatrix.h
+++ b/src/shogun/lib/GPUMatrix.h
@@ -41,6 +41,7 @@
 
 #include <shogun/lib/common.h>
 #include <memory>
+#include <viennacl/linalg/matrix_operations.hpp>
 
 #ifndef SWIG // SWIG should skip this part
 namespace viennacl
diff --git a/src/shogun/mathematics/linalg/internal/implementation/Apply.h b/src/shogun/mathematics/linalg/internal/implementation/Apply.h
deleted file mode 100644
index 4e9a3c1c10c..00000000000
--- a/src/shogun/mathematics/linalg/internal/implementation/Apply.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright (c) The Shogun Machine Learning Toolbox
- * Written (w) 2015 Soumyajit De
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * The views and conclusions contained in the software and documentation are those
- * of the authors and should not be interpreted as representing official policies,
- * either expressed or implied, of the Shogun Development Team.
- */
-
-#ifndef APPLY_IMPL_H_
-#define APPLY_IMPL_H_
-
-#include <shogun/lib/config.h>
-#include <shogun/lib/SGMatrix.h>
-#include <shogun/lib/SGVector.h>
-
-#include <shogun/mathematics/eigen3.h>
-
-#ifdef HAVE_VIENNACL
-#include <shogun/lib/GPUMatrix.h>
-#include <shogun/lib/GPUVector.h>
-#include <viennacl/linalg/matrix_operations.hpp>
-#include <viennacl/linalg/vector_operations.hpp>
-#include <viennacl/matrix.hpp>
-#endif // HAVE_VIENNACL
-
-#include <type_traits>
-
-namespace shogun
-{
-
-namespace linalg
-{
-
-namespace implementation
-{
-
-/**
- * @brief Generic class which is specialized for different backends to perform apply
- */
-template <Backend backend, class Matrix, class Vector>
-struct apply
-{
-};
-
-/**
- * @brief Partial specialization of apply for the Eigen3 backend
- */
-template <class Matrix, class Vector>
-struct apply<Backend::EIGEN3, Matrix, Vector>
-{
-	static_assert(std::is_same<typename Matrix::Scalar,typename Vector::Scalar>::value,
-			"Different numeric scalar types for matrix and vector not allowed!\n");
-
-	/** Scalar type */
-	typedef typename Matrix::Scalar T;
-
-	/** Eigen matrix type */
-	typedef Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> MatrixXt;
-
-	/** Eigen Vector type */
-	typedef Eigen::Matrix<T,Eigen::Dynamic,1> VectorXt;
-
-	/** Performs the operation of matrix applied to a vector \f$x = Ab\f$.
-	 *
-	 * @param A The matrix
-	 * @param b The vector
-	 * @param transpose Whether to transpose A before applying to b
-	 * @return x Result vector
-	 */
-	static SGVector<T> compute(SGMatrix<T> A, SGVector<T> b, bool transpose)
-	{
-		SGVector<T> x(A.num_rows);
-		compute(A, b, x, transpose);
-		return x;
-	}
-
-	/** Performs the operation of matrix applied to a vector \f$x = Ab\f$.
-	 *
-	 * @param A The matrix
-	 * @param b The vector
-	 * @param x Result vector
-	 * @param transpose Whether to transpose A before applying to b
-	 */
-	static void compute(SGMatrix<T> A, SGVector<T> b, SGVector<T> x, bool transpose)
-	{
-		Eigen::Map<MatrixXt> A_eig=A;
-		Eigen::Map<VectorXt> b_eig=b;
-		Eigen::Map<VectorXt> x_eig=x;
-
-		if (transpose)
-			x_eig=A_eig.transpose()*b_eig;
-		else
-			x_eig=A_eig*b_eig;
-	}
-};
-
-#ifdef HAVE_VIENNACL
-/**
- * @brief Partial specialization of apply for the ViennaCL backend
- */
-template <class Matrix, class Vector>
-struct apply<Backend::VIENNACL, Matrix, Vector>
-{
-	static_assert(std::is_same<typename Matrix::Scalar,typename Vector::Scalar>::value,
-			"Different numeric scalar types for matrix and vector not allowed!\n");
-
-	/** Scalar type */
-	typedef typename Matrix::Scalar T;
-
-	/** Performs the operation of matrix applied to a vector \f$x = Ab\f$.
-	 *
-	 * @param A The matrix
-	 * @param b The vector
-	 * @param transpose Whether to transpose A before applying to b
-	 * @return x Result vector
-	 */
-	static CGPUVector<T> compute(CGPUMatrix<T> A, CGPUVector<T> b, bool transpose)
-	{
-		CGPUVector<T> x(A.num_rows);
-		compute(A, b, x, transpose);
-		return x;
-	}
-
-	/** Performs the operation of matrix applied to a vector \f$x = Ab\f$.
-	 *
-	 * @param A The matrix
-	 * @param b The vector
-	 * @param x Result vector
-	 * @param transpose Whether to transpose A before applying to b
-	 */
-	static void compute(CGPUMatrix<T> A, CGPUVector<T> b, CGPUVector<T> x, bool transpose)
-	{
-		if (transpose)
-			x.vcl_vector()=viennacl::linalg::prod(viennacl::trans(A.vcl_matrix()), b.vcl_vector());
-		else
-			x.vcl_vector()=viennacl::linalg::prod(A.vcl_matrix(), b.vcl_vector());
-	}
-};
-#endif // HAVE_VIENNACL
-
-}
-
-}
-
-}
-#endif // APPLY_IMPL_H_
diff --git a/src/shogun/mathematics/linalg/internal/implementation/ElementwiseProduct.h b/src/shogun/mathematics/linalg/internal/implementation/ElementwiseProduct.h
deleted file mode 100644
index 7db4c969411..00000000000
--- a/src/shogun/mathematics/linalg/internal/implementation/ElementwiseProduct.h
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- * Copyright (c) The Shogun Machine Learning Toolbox
- * Written (w) 2014 Khaled Nasr
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * The views and conclusions contained in the software and documentation are those
- * of the authors and should not be interpreted as representing official policies,
- * either expressed or implied, of the Shogun Development Team.
- */
-
-#ifndef ELEMENTWISE_PRODUCT_IMPL_H_
-#define ELEMENTWISE_PRODUCT_IMPL_H_
-
-#include <shogun/lib/config.h>
-#include <shogun/lib/SGMatrix.h>
-
-#include <shogun/mathematics/eigen3.h>
-
-#ifdef HAVE_VIENNACL
-#include <shogun/lib/GPUMatrix.h>
-#include <viennacl/linalg/matrix_operations.hpp>
-#endif // HAVE_VIENNACL
-
-namespace shogun
-{
-
-namespace linalg
-{
-
-namespace implementation
-{
-
-/** Generic class which is specialized for different backends to perform
- * elementwise multiplication
- */
-template <Backend backend, class Matrix>
-struct elementwise_product
-{
-	/** Scalar type */
-	typedef typename Matrix::Scalar T;
-
-	/** Performs the operation C = A .* B where ".*" denotes elementwise multiplication */
-	static void compute(Matrix A, Matrix B, Matrix C);
-};
-
-
-/** Specialization of elementwise_product for the Eigen3 backend */
-template <class Matrix>
-struct elementwise_product<Backend::EIGEN3, Matrix>
-{
-	/** Scalar type */
-	typedef typename Matrix::Scalar T;
-
-	/** Return type */
-	typedef SGMatrix<T> ReturnType;
-
-	/** Eigen3 matrix type */
-	typedef Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> MatrixXt;
-
-	/** Performs the operation C = A .* B where ".*" denotes elementwise multiplication.
-	 *
-	 * This version returns the result in a newly created matrix. If elementwise-product
-	 * is desired that will work irrespective of the backend and the matrix type used,
-	 * then this method should be used.
-	 *
-	 * @param A First matrix
-	 * @param B Second matrix
-	 * @return The result of the operation
-	 */
-	static ReturnType compute(SGMatrix<T> A, SGMatrix<T> B)
-	{
-		REQUIRE(A.matrix, "Matrix A is not initialized!\n");
-		REQUIRE(B.matrix, "Matrix A is not initialized!\n");
-
-		REQUIRE(A.num_rows == B.num_rows && A.num_cols == B.num_cols,
-				"Dimension mismatch! A(%d x %d) vs B(%d x %d)\n",
-				A.num_rows, A.num_cols, B.num_rows, B.num_cols);
-
-		ReturnType retMatrix(A.num_rows, A.num_cols);
-		compute(A, B, retMatrix);
-
-		return retMatrix;
-	}
-
-	/** Performs the operation C = A .* B where ".*" denotes elementwise multiplication.
-	 *
-	 * This version should be used for backend specific code requirements. For example,
-	 * use this with CGPUMatrix and explicitly set ViennaCL backend, or SGMatrix and
-	 * explicitly set Eigen3 backend. If matrix-type/backend-type independent code is
-	 * desired, use the version that does not support preallocated result matrix but
-	 * returns the result in a newly created matrix instead.
-	 *
-	 * @param A First matrix
-	 * @param B Second matrix
-	 * @param C Result of the operation
-	 */
-	static void compute(SGMatrix<T> A, SGMatrix<T> B, SGMatrix<T> C)
-	{
-		Eigen::Map<MatrixXt> A_eig = A;
-		Eigen::Map<MatrixXt> B_eig = B;
-		Eigen::Map<MatrixXt> C_eig = C;
-
-		C_eig = A_eig.array() * B_eig.array();
-	}
-};
-
-#ifdef HAVE_VIENNACL
-
-/** Specialization of elementwise_product for the ViennaCL backend */
-template <class Matrix>
-struct elementwise_product<Backend::VIENNACL, Matrix>
-{
-	/** Scalar type */
-	typedef typename Matrix::Scalar T;
-
-	/** Return type */
-	typedef CGPUMatrix<T> ReturnType;
-
-	/** Performs the operation C = A .* B where ".*" denotes elementwise multiplication.
-	 *
-	 * This version returns the result in a newly created matrix. If elementwise-product
-	 * is desired that will work irrespective of the backend and the matrix type used,
-	 * then this method should be used.
-	 *
-	 * @param A First matrix
-	 * @param B Second matrix
-	 * @return The result of the operation
-	 */
-	static ReturnType compute(CGPUMatrix<T> A, CGPUMatrix<T> B)
-	{
-		REQUIRE(A.matrix, "Matrix A is not initialized!\n");
-		REQUIRE(B.matrix, "Matrix A is not initialized!\n");
-
-		REQUIRE(A.num_rows == B.num_rows && A.num_cols == B.num_cols,
-				"Dimension mismatch! A(%d x %d) vs B(%d x %d)\n",
-				A.num_rows, A.num_cols, B.num_rows, B.num_cols);
-
-		ReturnType retMatrix(A.num_rows, A.num_cols);
-		compute(A, B, retMatrix);
-
-		return retMatrix;
-	}
-
-	/** Performs the operation C = A .* B where ".*" denotes elementwise multiplication.
-	 *
-	 * This version should be used for backend specific code requirements. For example,
-	 * use this with CGPUMatrix and explicitly set ViennaCL backend, or SGMatrix and
-	 * explicitly set Eigen3 backend. If matrix-type/backend-type independent code is
-	 * desired, use the version that does not support preallocated result matrix but
-	 * returns the result in a newly created matrix instead.
-	 *
-	 * @param A First matrix
-	 * @param B Second matrix
-	 * @param C Result of the operation
-	 */
-	static void compute(CGPUMatrix<T> A, CGPUMatrix<T> B, CGPUMatrix<T> C)
-	{
-		C.vcl_matrix() = viennacl::linalg::element_prod(A.vcl_matrix(), B.vcl_matrix());
-	}
-};
-
-#endif // HAVE_VIENNACL
-
-}
-
-}
-
-}
-#endif // ELEMENTWISE_PRODUCT_IMPL_H_
diff --git a/src/shogun/mathematics/linalg/internal/modules/Core.h b/src/shogun/mathematics/linalg/internal/modules/Core.h
index 62136ab15c0..5937aca1030 100644
--- a/src/shogun/mathematics/linalg/internal/modules/Core.h
+++ b/src/shogun/mathematics/linalg/internal/modules/Core.h
@@ -33,8 +33,6 @@
 #define CORE_H_
 
 #include <shogun/mathematics/linalg/internal/implementation/ElementwiseSquare.h>
-#include <shogun/mathematics/linalg/internal/implementation/Apply.h>
-#include <shogun/mathematics/linalg/internal/implementation/ElementwiseProduct.h>
 
 namespace shogun
 {
@@ -43,74 +41,6 @@ namespace linalg
 {
 
 #ifdef HAVE_LINALG_LIB
-/** Performs the operation of matrix applied to a vector \f$x = Ab\f$.
- *
- * This version should be used for backend specific code requirements. For example,
- * use this with CGPUMatrix, CGPUVector and explicitly set ViennaCL backend, or
- * SGMatrix, SGVector and explicitly set Eigen3 backend. If matrix-type/backend-type
- * independent code is desired, use the version that does not support preallocated
- * result vector but returns the result in a newly created vector instead.
- *
- * @param A The matrix
- * @param b The vector
- * @param x Result vector
- */
-template <Backend backend=linalg_traits<Core>::backend,class Matrix,class Vector>
-void apply(Matrix A, Vector b, Vector x, bool transpose=false)
-{
-	implementation::apply<backend,Matrix,Vector>::compute(A, b, x, transpose);
-}
-
-/** Performs the operation of matrix applied to a vector \f$x = Ab\f$.
- *
- * This version returns the result in a newly created vector. If apply is desired
- * that will work irrespective of the backend and the matrix/vector type used,
- * then this method should be used.
- *
- * @param A The matrix
- * @param b The vector
- * @param x Result vector
- */
-template <Backend backend=linalg_traits<Core>::backend,class Matrix,class Vector>
-Vector apply(Matrix A, Vector b, bool transpose=false)
-{
-	return implementation::apply<backend,Matrix,Vector>::compute(A, b, transpose);
-}
-
-/** Performs the operation C = A .* B where ".*" denotes elementwise multiplication.
- *
- * This version should be used for backend specific code requirements. For example,
- * use this with CGPUMatrix and explicitly set ViennaCL backend, or SGMatrix and
- * explicitly set Eigen3 backend. If matrix-type/backend-type independent code is
- * desired, use the version that does not support preallocated result matrix but
- * returns the result in a newly created matrix instead.
- *
- * @param A First matrix
- * @param B Second matrix
- * @param C Result of the operation
- */
-template <Backend backend=linalg_traits<Core>::backend,class Matrix>
-void elementwise_product(Matrix A, Matrix B, Matrix C)
-{
-	implementation::elementwise_product<backend, Matrix>::compute(A, B, C);
-}
-
-/** Performs the operation C = A .* B where ".*" denotes elementwise multiplication.
- *
- * This version returns the result in a newly created matrix. If elementwise-product
- * is desired that will work irrespective of the backend and the matrix type used,
- * then this method should be used.
- *
- * @param A First matrix
- * @param B Second matrix
- * @return The result of the operation
- */
-template <Backend backend=linalg_traits<Core>::backend,class Matrix>
-typename implementation::elementwise_product<backend,Matrix>::ReturnType elementwise_product(Matrix A, Matrix B)
-{
-	return implementation::elementwise_product<backend,Matrix>::compute(A, B);
-}
-
 /**
  * Wrapper method for internal implementation of square of co-efficients that works
  * with generic dense matrices.
diff --git a/tests/unit/mathematics/linalg/Apply_unittest.cc b/tests/unit/mathematics/linalg/Apply_unittest.cc
deleted file mode 100644
index ca95bb73aee..00000000000
--- a/tests/unit/mathematics/linalg/Apply_unittest.cc
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * Copyright (c) The Shogun Machine Learning Toolbox
- * Written (w) 2015 Soumyajit De
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * The views and conclusions contained in the software and documentation are those
- * of the authors and should not be interpreted as representing official policies,
- * either expressed or implied, of the Shogun Development Team.
- */
-
-#include <shogun/lib/config.h>
-
-#ifdef HAVE_LINALG_LIB
-#include <shogun/mathematics/linalg/linalg.h>
-#include <shogun/lib/SGMatrix.h>
-#include <shogun/lib/SGVector.h>
-#include <gtest/gtest.h>
-
-#include <shogun/mathematics/eigen3.h>
-
-#ifdef HAVE_VIENNACL
-#include <shogun/lib/GPUMatrix.h>
-#include <shogun/lib/GPUVector.h>
-#endif // HAVE_VIENNACL
-
-using namespace shogun;
-
-TEST(Apply, SGMatrix_Eigen3_backend)
-{
-	const index_t rows=4;
-	const index_t cols=3;
-
-	SGMatrix<float64_t> A(rows, cols);
-	SGVector<float64_t> b(cols);
-	SGVector<float64_t> x(rows);
-
-	for (index_t i=0; i<cols; i++)
-	{
-		for (index_t j=0; j<rows; ++j)
-			A(j, i)=i*rows+j;
-		b[i]=0.5*i;
-	}
-
-	linalg::apply<linalg::Backend::EIGEN3>(A, b, x);
-
-	float64_t ref[] = {10,11.5,13,14.5};
-
-	for (index_t i=0; i<x.vlen; ++i)
-		EXPECT_NEAR(x[i], ref[i], 1e-15);
-}
-
-TEST(Apply, SGMatrix_Eigen3_backend_transpose)
-{
-	const index_t rows=3;
-	const index_t cols=4;
-
-	SGMatrix<float64_t> A(rows, cols);
-	SGVector<float64_t> b(rows);
-	SGVector<float64_t> x(cols);
-
-	for (index_t i=0; i<rows; i++)
-	{
-		for (index_t j=0; j<cols; ++j)
-			A(i, j)=i*cols+j;
-		b[i]=0.5*i;
-	}
-
-	linalg::apply<linalg::Backend::EIGEN3>(A, b, x, true);
-
-	float64_t ref[] = {10,11.5,13,14.5};
-
-	for (index_t i=0; i<x.vlen; ++i)
-		EXPECT_NEAR(x[i], ref[i], 1e-15);
-}
-
-#ifdef HAVE_VIENNACL
-TEST(Apply, CGPUMatrix_Eigen3_backend)
-{
-	const index_t rows=4;
-	const index_t cols=3;
-
-	CGPUMatrix<float64_t> A(rows, cols);
-	CGPUVector<float64_t> b(cols);
-
-	for (index_t i=0; i<cols; i++)
-	{
-		for (index_t j=0; j<rows; ++j)
-			A(j, i)=i*rows+j;
-		b[i]=0.5*i;
-	}
-
-	CGPUVector<float64_t> x=linalg::apply<linalg::Backend::EIGEN3>(A, b);
-
-	float64_t ref[] = {10,11.5,13,14.5};
-
-	for (index_t i=0; i<x.vlen; ++i)
-		EXPECT_NEAR(x[i], ref[i], 1e-15);
-}
-
-TEST(Apply, CGPUMatrix_ViennaCL_backend)
-{
-	const index_t rows=4;
-	const index_t cols=3;
-
-	CGPUMatrix<float64_t> A(rows, cols);
-	CGPUVector<float64_t> b(cols);
-	CGPUVector<float64_t> x(rows);
-
-	for (index_t i=0; i<cols; i++)
-	{
-		for (index_t j=0; j<rows; ++j)
-			A(j, i)=i*rows+j;
-		b[i]=0.5*i;
-	}
-
-	linalg::apply<linalg::Backend::VIENNACL>(A, b, x);
-
-	float64_t ref[] = {10,11.5,13,14.5};
-
-	for (index_t i=0; i<x.vlen; ++i)
-		EXPECT_NEAR(x[i], ref[i], 1e-15);
-}
-
-TEST(Apply, CGPUMatrix_ViennaCL_backend_transpose)
-{
-	const index_t rows=3;
-	const index_t cols=4;
-
-	CGPUMatrix<float64_t> A(rows, cols);
-	CGPUVector<float64_t> b(rows);
-	CGPUVector<float64_t> x(cols);
-
-	for (index_t i=0; i<rows; i++)
-	{
-		for (index_t j=0; j<cols; ++j)
-			A(i, j)=i*cols+j;
-		b[i]=0.5*i;
-	}
-
-	linalg::apply<linalg::Backend::VIENNACL>(A, b, x, true);
-
-	float64_t ref[] = {10,11.5,13,14.5};
-
-	for (index_t i=0; i<x.vlen; ++i)
-		EXPECT_NEAR(x[i], ref[i], 1e-15);
-}
-
-TEST(Apply, SGMatrix_ViennaCL_backend)
-{
-	const index_t rows=4;
-	const index_t cols=3;
-
-	SGMatrix<float64_t> A(rows, cols);
-	SGVector<float64_t> b(cols);
-
-	for (index_t i=0; i<cols; i++)
-	{
-		for (index_t j=0; j<rows; ++j)
-			A(j, i)=i*rows+j;
-		b[i]=0.5*i;
-	}
-
-	SGVector<float64_t> x=linalg::apply<linalg::Backend::VIENNACL>(A, b);
-
-	float64_t ref[] = {10,11.5,13,14.5};
-
-	for (index_t i=0; i<x.vlen; ++i)
-		EXPECT_NEAR(x[i], ref[i], 1e-15);
-}
-#endif // HAVE_VIENNACL
-#endif // HAVE_LINALG_LIB
diff --git a/tests/unit/mathematics/linalg/ElementwiseProduct_unittest.cc b/tests/unit/mathematics/linalg/ElementwiseProduct_unittest.cc
deleted file mode 100644
index aef05f6304e..00000000000
--- a/tests/unit/mathematics/linalg/ElementwiseProduct_unittest.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) The Shogun Machine Learning Toolbox
- * Written (w) 2014 Khaled Nasr
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * The views and conclusions contained in the software and documentation are those
- * of the authors and should not be interpreted as representing official policies,
- * either expressed or implied, of the Shogun Development Team.
- */
-
-#include <shogun/lib/config.h>
-
-#ifdef HAVE_LINALG_LIB
-#include <shogun/mathematics/linalg/linalg.h>
-#include <shogun/lib/SGMatrix.h>
-#include <gtest/gtest.h>
-
-#include <shogun/mathematics/eigen3.h>
-
-#ifdef HAVE_VIENNACL
-#include <shogun/lib/GPUMatrix.h>
-#endif
-
-using namespace shogun;
-
-TEST(ElementwiseProduct, SGMatrix_eigen3_backend)
-{
-	SGMatrix<float64_t> A(3,3);
-	SGMatrix<float64_t> B(3,3);
-	SGMatrix<float64_t> C(3,3);
-
-	for (int32_t i=0; i<9; i++)
-	{
-		A[i] = i;
-		B[i] = 0.5*i;
-	}
-
-	linalg::elementwise_product<linalg::Backend::EIGEN3>(A, B, C);
-
-	for (int32_t i=0; i<9; i++)
-		EXPECT_NEAR(A[i]*B[i], C[i], 1e-15);
-}
-
-#ifdef HAVE_VIENNACL
-TEST(ElementwiseProduct, CGPUMatrix_eigen3_backend)
-{
-	CGPUMatrix<float64_t> A(3,3);
-	CGPUMatrix<float64_t> B(3,3);
-
-	for (int32_t i=0; i<9; i++)
-	{
-		A[i] = i;
-		B[i] = 0.5*i;
-	}
-
-	CGPUMatrix<float64_t> C = linalg::elementwise_product<linalg::Backend::EIGEN3>(A, B);
-
-	for (int32_t i=0; i<9; i++)
-		EXPECT_NEAR(A[i]*B[i], C[i], 1e-15);
-}
-
-TEST(ElementwiseProduct, CGPUMatrix_viennacl_backend)
-{
-	CGPUMatrix<float64_t> A(3,3);
-	CGPUMatrix<float64_t> B(3,3);
-	CGPUMatrix<float64_t> C(3,3);
-
-	for (int32_t i=0; i<9; i++)
-	{
-		A[i] = i;
-		B[i] = 0.5*i;
-	}
-
-	linalg::elementwise_product<linalg::Backend::VIENNACL>(A, B, C);
-
-	for (int32_t i=0; i<9; i++)
-		EXPECT_NEAR(A[i]*B[i], C[i], 1e-15);
-}
-
-TEST(ElementwiseProduct, SGMatrix_viennacl_backend)
-{
-	SGMatrix<float64_t> A(3,3);
-	SGMatrix<float64_t> B(3,3);
-
-	for (int32_t i=0; i<9; i++)
-	{
-		A[i] = i;
-		B[i] = 0.5*i;
-	}
-
-	SGMatrix<float64_t> C = linalg::elementwise_product<linalg::Backend::VIENNACL>(A, B);
-
-	for (int32_t i=0; i<9; i++)
-		EXPECT_NEAR(A[i]*B[i], C[i], 1e-15);
-}
-#endif // HAVE_VIENNACL
-
-#endif // HAVE_LINALG_LIB