GPU: Add BLAS-1 ops, DeviceScalar, device-resident SpMV, and CG interop (5/5)

Add the operator interface needed for GPU iterative solvers:

- BLAS Level-1 on DeviceMatrix: dot(), norm(), squaredNorm(), setZero(),
  noalias(), operator+=/-=/\*= dispatching to cuBLAS axpy/scal/dot/nrm2.
- DeviceScalar<Scalar>: device-resident scalar returned by reductions.
  Defers host sync until value is read (implicit conversion). Device-side
  division via NPP for real types.
- GpuContext: stream-borrowing constructor, setThreadLocal(), cublasLtHandle(),
  cusparseHandle().
- GEMM upgraded from cublasGemmEx to cublasLtMatmul with heuristic algorithm
  selection and plan caching.
- GpuSparseContext: GpuContext& constructor for same-stream execution,
  deviceView() returning DeviceSparseView with operator* for device-resident
  SpMV (d_y = d_A * d_x).
- geam expressions: d_C = d_A + alpha * d_B via cublasXgeam.
- GpuSVD::matrixV() convenience wrapper.

These additions make DeviceMatrix usable as a VectorType in Eigen algorithm
templates. Conjugate gradient is the motivating example and is tested against
CPU ConjugateGradient for correctness.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

test/CMakeLists.txt

@@ -481,13 +481,13 @@ if(CUDA_FOUND AND EIGEN_TEST_CUDA)
   ei_add_test(gpu_basic)
   ei_add_test(gpu_library_example "" "CUDA::cusolver")
 
-  # DeviceMatrix tests: only CUDA runtime, no NVIDIA libraries.
+  # DeviceMatrix tests: CUDA runtime + cuBLAS + cuSOLVER (for BLAS-1 ops via GpuContext).
   unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
   add_executable(gpu_device_matrix gpu_device_matrix.cpp)
   target_include_directories(gpu_device_matrix PRIVATE
     "${CUDA_TOOLKIT_ROOT_DIR}/include"
     "${CMAKE_CURRENT_BINARY_DIR}")
-  target_link_libraries(gpu_device_matrix Eigen3::Eigen CUDA::cudart)
+  target_link_libraries(gpu_device_matrix Eigen3::Eigen CUDA::cudart CUDA::cublas CUDA::cusolver CUDA::npps CUDA::nppc)
   target_compile_definitions(gpu_device_matrix PRIVATE
     EIGEN_TEST_MAX_SIZE=${EIGEN_TEST_MAX_SIZE}
     EIGEN_TEST_PART_ALL=1)
@@ -575,7 +575,7 @@ if(CUDA_FOUND AND EIGEN_TEST_CUDA)
       "${CUDA_TOOLKIT_ROOT_DIR}/include"
       "${CMAKE_CURRENT_BINARY_DIR}")
     target_link_libraries(gpu_cusparse_spmv
-      Eigen3::Eigen CUDA::cudart CUDA::cusparse)
+      Eigen3::Eigen CUDA::cudart CUDA::cusparse CUDA::cublas CUDA::cusolver)
     target_compile_definitions(gpu_cusparse_spmv PRIVATE
       EIGEN_TEST_MAX_SIZE=${EIGEN_TEST_MAX_SIZE}
       EIGEN_TEST_PART_ALL=1)
@@ -584,6 +584,23 @@ if(CUDA_FOUND AND EIGEN_TEST_CUDA)
     add_dependencies(buildtests_gpu gpu_cusparse_spmv)
     set_property(TEST gpu_cusparse_spmv APPEND PROPERTY LABELS "Official;gpu")
     set_property(TEST gpu_cusparse_spmv PROPERTY SKIP_RETURN_CODE 77)
+
+    # End-to-end GPU CG test: Eigen's ConjugateGradient with DeviceMatrix.
+    add_executable(gpu_cg gpu_cg.cpp)
+    target_include_directories(gpu_cg PRIVATE
+      "${CUDA_TOOLKIT_ROOT_DIR}/include"
+      "${CMAKE_CURRENT_BINARY_DIR}")
+    target_link_libraries(gpu_cg
+      Eigen3::Eigen CUDA::cudart CUDA::cusparse CUDA::cublas CUDA::cusolver CUDA::npps CUDA::nppc)
+    target_compile_definitions(gpu_cg PRIVATE
+      EIGEN_TEST_MAX_SIZE=${EIGEN_TEST_MAX_SIZE}
+      EIGEN_TEST_PART_ALL=1)
+    add_test(NAME gpu_cg COMMAND gpu_cg)
+    add_dependencies(buildtests gpu_cg)
+    add_dependencies(buildtests_gpu gpu_cg)
+    set_property(TEST gpu_cg APPEND PROPERTY LABELS "Official;gpu")
+    set_property(TEST gpu_cg PROPERTY SKIP_RETURN_CODE 77)
+
     set(EIGEN_ADD_TEST_FILENAME_EXTENSION "cu")
   endif()
 

test/gpu_cg.cpp

@@ -0,0 +1,224 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// End-to-end test: CG algorithm running on GPU via DeviceMatrix.
+//
+// Uses DeviceSparseView for SpMV, DeviceMatrix for vectors, DeviceScalar
+// for deferred reductions. Verifies correctness against CPU ConjugateGradient.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Sparse>
+#include <Eigen/IterativeLinearSolvers>
+#include <Eigen/GPU>
+
+using namespace Eigen;
+
+// ---- Helper: build a sparse SPD matrix --------------------------------------
+
+template <typename Scalar>
+SparseMatrix<Scalar, ColMajor, int> make_spd(Index n, double density = 0.1) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat R(n, n);
+  R.reserve(VectorXi::Constant(n, static_cast<int>(n * density) + 1));
+  for (Index j = 0; j < n; ++j) {
+    for (Index i = 0; i < n; ++i) {
+      if (i == j || (std::rand() / double(RAND_MAX)) < density) {
+        R.insert(i, j) = Scalar(std::rand() / double(RAND_MAX) - 0.5);
+      }
+    }
+  }
+  R.makeCompressed();
+  SpMat A = R.adjoint() * R;
+  for (Index i = 0; i < n; ++i) A.coeffRef(i, i) += Scalar(RealScalar(n));
+  A.makeCompressed();
+  return A;
+}
+
+// ---- GPU CG without preconditioner ------------------------------------------
+
+template <typename Scalar>
+void test_gpu_cg(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  // CPU reference (identity preconditioner to match GPU).
+  ConjugateGradient<SpMat, Lower | Upper, IdentityPreconditioner> cpu_cg;
+  cpu_cg.setMaxIterations(1000);
+  cpu_cg.setTolerance(RealScalar(1e-8));
+  cpu_cg.compute(A);
+  Vec x_cpu = cpu_cg.solve(b);
+  VERIFY_IS_EQUAL(cpu_cg.info(), Success);
+
+  // GPU CG: mirrors Eigen's conjugate_gradient() using DeviceMatrix ops.
+  GpuContext ctx;
+  GpuContext::setThreadLocal(&ctx);
+  GpuSparseContext<Scalar> spmv_ctx(ctx);
+  auto mat = spmv_ctx.deviceView(A);
+
+  auto d_b = DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+  DeviceMatrix<Scalar> d_x(n, 1);
+  d_x.setZero(ctx);
+
+  // r = b (since x=0)
+  DeviceMatrix<Scalar> residual(n, 1);
+  residual.copyFrom(ctx, d_b);
+
+  RealScalar rhsNorm2 = d_b.squaredNorm(ctx);
+  RealScalar tol = RealScalar(1e-8);
+  RealScalar threshold = tol * tol * rhsNorm2;
+  RealScalar residualNorm2 = residual.squaredNorm(ctx);
+
+  // p = r (no preconditioner)
+  DeviceMatrix<Scalar> p(n, 1);
+  p.copyFrom(ctx, residual);
+  DeviceMatrix<Scalar> z(n, 1), tmp(n, 1);
+
+  auto absNew = residual.dot(ctx, p);
+  Index maxIters = 1000;
+  Index i = 0;
+  while (i < maxIters) {
+    tmp.noalias() = mat * p;
+
+    auto alpha = absNew / p.dot(ctx, tmp);
+    d_x += alpha * p;
+    residual -= alpha * tmp;
+
+    residualNorm2 = residual.squaredNorm(ctx);
+    if (residualNorm2 < threshold) break;
+
+    // z = r (no preconditioner)
+    z.copyFrom(ctx, residual);
+
+    auto absOld = std::move(absNew);
+    absNew = residual.dot(ctx, z);
+    auto beta = absNew / absOld;
+
+    p *= Scalar(beta);
+    p += z;
+    i++;
+  }
+
+  GpuContext::setThreadLocal(nullptr);
+
+  Vec x_gpu = d_x.toHost(ctx.stream());
+
+  // Verify residual.
+  Vec r = A * x_gpu - b;
+  RealScalar relres = r.norm() / b.norm();
+  VERIFY(relres < RealScalar(1e-6));
+
+  // Compare with CPU.
+  RealScalar sol_tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((x_gpu - x_cpu).norm() / (x_cpu.norm() + RealScalar(1)) < sol_tol);
+}
+
+// ---- GPU CG with Jacobi preconditioner --------------------------------------
+
+template <typename Scalar>
+void test_gpu_cg_jacobi(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  // CPU reference.
+  ConjugateGradient<SpMat, Lower | Upper> cpu_cg;
+  cpu_cg.setMaxIterations(1000);
+  cpu_cg.setTolerance(RealScalar(1e-8));
+  cpu_cg.compute(A);
+  Vec x_cpu = cpu_cg.solve(b);
+
+  // Extract inverse diagonal.
+  Vec invdiag(n);
+  for (Index j = 0; j < A.outerSize(); ++j) {
+    typename SpMat::InnerIterator it(A, j);
+    while (it && it.index() != j) ++it;
+    if (it && it.index() == j && it.value() != Scalar(0))
+      invdiag(j) = Scalar(1) / it.value();
+    else
+      invdiag(j) = Scalar(1);
+  }
+
+  // GPU CG with Jacobi preconditioner.
+  GpuContext ctx;
+  GpuContext::setThreadLocal(&ctx);
+  GpuSparseContext<Scalar> spmv_ctx(ctx);
+  auto mat = spmv_ctx.deviceView(A);
+  auto d_invdiag = DeviceMatrix<Scalar>::fromHost(invdiag, ctx.stream());
+
+  auto d_b = DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+  DeviceMatrix<Scalar> d_x(n, 1);
+  d_x.setZero(ctx);
+
+  DeviceMatrix<Scalar> residual(n, 1);
+  residual.copyFrom(ctx, d_b);
+
+  RealScalar rhsNorm2 = d_b.squaredNorm(ctx);
+  RealScalar tol = RealScalar(1e-8);
+  RealScalar threshold = tol * tol * rhsNorm2;
+  RealScalar residualNorm2 = residual.squaredNorm(ctx);
+
+  // p = precond.solve(r) = invdiag .* r
+  DeviceMatrix<Scalar> p = d_invdiag.cwiseProduct(ctx, residual);
+  DeviceMatrix<Scalar> z(n, 1), tmp(n, 1);
+
+  auto absNew = residual.dot(ctx, p);
+  Index maxIters = 1000;
+  Index i = 0;
+  while (i < maxIters) {
+    tmp.noalias() = mat * p;
+
+    auto alpha = absNew / p.dot(ctx, tmp);
+    d_x += alpha * p;
+    residual -= alpha * tmp;
+
+    residualNorm2 = residual.squaredNorm(ctx);
+    if (residualNorm2 < threshold) break;
+
+    // z = precond.solve(r) = invdiag .* r
+    z.cwiseProduct(ctx, d_invdiag, residual);
+
+    auto absOld = std::move(absNew);
+    absNew = residual.dot(ctx, z);
+    auto beta = absNew / absOld;
+
+    p *= beta;
+    p += z;
+    i++;
+  }
+
+  GpuContext::setThreadLocal(nullptr);
+
+  Vec x_gpu = d_x.toHost(ctx.stream());
+
+  Vec r = A * x_gpu - b;
+  RealScalar relres = r.norm() / b.norm();
+  VERIFY(relres < RealScalar(1e-6));
+
+  RealScalar sol_tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((x_gpu - x_cpu).norm() / (x_cpu.norm() + RealScalar(1)) < sol_tol);
+}
+
+EIGEN_DECLARE_TEST(gpu_cg) {
+  CALL_SUBTEST(test_gpu_cg<double>(64));
+  CALL_SUBTEST(test_gpu_cg<double>(256));
+  CALL_SUBTEST(test_gpu_cg<float>(64));
+  CALL_SUBTEST(test_gpu_cg_jacobi<double>(64));
+  CALL_SUBTEST(test_gpu_cg_jacobi<double>(256));
+  CALL_SUBTEST(test_gpu_cg_jacobi<float>(64));
+}

test/gpu_cusparse_spmv.cpp

@@ -180,6 +180,105 @@ void test_empty() {
   VERIFY_IS_EQUAL(y.size(), 0);
 }
 
+// ---- DeviceMatrix SpMV (no host roundtrip) ----------------------------------
+
+template <typename Scalar>
+void test_spmv_device(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(n, n);
+  Vec x = Vec::Random(n);
+
+  // Use shared GpuContext for same-stream execution.
+  GpuContext gpu_ctx;
+  GpuSparseContext<Scalar> ctx(gpu_ctx);
+
+  auto d_x = DeviceMatrix<Scalar>::fromHost(x, gpu_ctx.stream());
+  DeviceMatrix<Scalar> d_y;
+
+  ctx.multiply(A, d_x, d_y);
+
+  Vec y_gpu = d_y.toHost(gpu_ctx.stream());
+  Vec y_cpu = A * x;
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- Expression syntax: d_y = d_A * d_x ------------------------------------
+
+template <typename Scalar>
+void test_spmv_expr(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(n, n);
+  Vec x = Vec::Random(n);
+
+  GpuContext gpu_ctx;
+  GpuSparseContext<Scalar> ctx(gpu_ctx);
+
+  // Upload sparse matrix and create device view.
+  auto d_A = ctx.deviceView(A);
+
+  // Upload x.
+  auto d_x = DeviceMatrix<Scalar>::fromHost(x, gpu_ctx.stream());
+
+  // Expression syntax: d_y = d_A * d_x
+  DeviceMatrix<Scalar> d_y;
+  d_y = d_A * d_x;
+
+  // Also test with noalias():
+  DeviceMatrix<Scalar> d_tmp;
+  d_tmp.noalias() = d_A * d_x;
+
+  Vec y_gpu = d_y.toHost(gpu_ctx.stream());
+  Vec tmp_gpu = d_tmp.toHost(gpu_ctx.stream());
+  Vec y_cpu = A * x;
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+  VERIFY((tmp_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- deviceView overwrite: second view replaces first -----------------------
+
+template <typename Scalar>
+void test_deviceview_overwrite(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A1 = make_sparse<Scalar>(n, n);
+  SpMat A2 = make_sparse<Scalar>(n, n);  // different random matrix
+
+  Vec x = Vec::Random(n);
+
+  GpuContext gpu_ctx;
+  GpuSparseContext<Scalar> ctx(gpu_ctx);
+
+  // First view: A1.
+  auto d_A1 = ctx.deviceView(A1);
+  auto d_x = DeviceMatrix<Scalar>::fromHost(x, gpu_ctx.stream());
+  DeviceMatrix<Scalar> d_y1;
+  d_y1 = d_A1 * d_x;
+  Vec y1_gpu = d_y1.toHost(gpu_ctx.stream());
+  Vec y1_cpu = A1 * x;
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y1_gpu - y1_cpu).norm() / (y1_cpu.norm() + RealScalar(1)) < tol);
+
+  // Second view overwrites first: now uses A2.
+  auto d_A2 = ctx.deviceView(A2);
+  DeviceMatrix<Scalar> d_y2;
+  d_y2 = d_A2 * d_x;
+  Vec y2_gpu = d_y2.toHost(gpu_ctx.stream());
+  Vec y2_cpu = A2 * x;
+  VERIFY((y2_gpu - y2_cpu).norm() / (y2_cpu.norm() + RealScalar(1)) < tol);
+}
+
 // ---- Per-scalar driver ------------------------------------------------------
 
 template <typename Scalar>
@@ -193,6 +292,9 @@ void test_scalar() {
   CALL_SUBTEST(test_identity<Scalar>(64));
   CALL_SUBTEST(test_reuse<Scalar>(64));
   CALL_SUBTEST(test_empty<Scalar>());
+  CALL_SUBTEST(test_spmv_device<Scalar>(64));
+  CALL_SUBTEST(test_spmv_expr<Scalar>(64));
+  CALL_SUBTEST(test_deviceview_overwrite<Scalar>(64));
 }
 
 EIGEN_DECLARE_TEST(gpu_cusparse_spmv) {

test/gpu_device_matrix.cpp

@@ -12,6 +12,7 @@
 
 #define EIGEN_USE_GPU
 #include "main.h"
+#include <Eigen/Sparse>
 #include <Eigen/GPU>
 
 using namespace Eigen;
@@ -230,6 +231,217 @@ void test_scalar() {
   CALL_SUBTEST(test_move_assign<Scalar>(64, 64));
 }
 
+// ---- BLAS-1: dot product ----------------------------------------------------
+
+template <typename Scalar>
+void test_blas1(Index n) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  // All BLAS-1 ops share one GpuContext — same stream, zero event overhead.
+  GpuContext ctx;
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  // dot
+  {
+    Vec a = Vec::Random(n);
+    Vec b = Vec::Random(n);
+    auto d_a = DeviceMatrix<Scalar>::fromHost(a, ctx.stream());
+    auto d_b = DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+    Scalar gpu_dot = d_a.dot(ctx, d_b);
+    Scalar cpu_dot = a.dot(b);
+    VERIFY(numext::abs(gpu_dot - cpu_dot) < tol * numext::abs(cpu_dot) + tol);
+  }
+
+  // norm / squaredNorm
+  {
+    Vec a = Vec::Random(n);
+    auto d_a = DeviceMatrix<Scalar>::fromHost(a, ctx.stream());
+    RealScalar gpu_norm = d_a.norm(ctx);
+    RealScalar cpu_norm = a.norm();
+    VERIFY(numext::abs(gpu_norm - cpu_norm) < tol * cpu_norm + tol);
+    RealScalar gpu_sqnorm = d_a.squaredNorm(ctx);
+    RealScalar cpu_sqnorm = a.squaredNorm();
+    VERIFY(numext::abs(gpu_sqnorm - cpu_sqnorm) < tol * cpu_sqnorm + tol);
+  }
+
+  // addScaled (axpy)
+  {
+    Vec x = Vec::Random(n);
+    Vec y = Vec::Random(n);
+    Scalar alpha(2.5);
+    Vec y_ref = y + alpha * x;
+    auto d_y = DeviceMatrix<Scalar>::fromHost(y, ctx.stream());
+    auto d_x = DeviceMatrix<Scalar>::fromHost(x, ctx.stream());
+    d_y.addScaled(ctx, alpha, d_x);
+    Vec y_gpu = d_y.toHost(ctx.stream());
+    VERIFY((y_gpu - y_ref).norm() < tol * y_ref.norm() + tol);
+  }
+
+  // scale (scal)
+  {
+    Vec x = Vec::Random(n);
+    Scalar alpha(3.0);
+    Vec x_ref = alpha * x;
+    auto d_x = DeviceMatrix<Scalar>::fromHost(x, ctx.stream());
+    d_x.scale(ctx, alpha);
+    Vec x_gpu = d_x.toHost(ctx.stream());
+    VERIFY((x_gpu - x_ref).norm() < tol * x_ref.norm() + tol);
+  }
+
+  // copyFrom
+  {
+    Vec x = Vec::Random(n);
+    auto d_x = DeviceMatrix<Scalar>::fromHost(x, ctx.stream());
+    DeviceMatrix<Scalar> d_y;
+    d_y.copyFrom(ctx, d_x);
+    Vec y = d_y.toHost(ctx.stream());
+    VERIFY_IS_APPROX(y, x);
+  }
+
+  // setZero
+  {
+    Vec x = Vec::Random(n);
+    auto d_x = DeviceMatrix<Scalar>::fromHost(x, ctx.stream());
+    d_x.setZero(ctx);
+    Vec result = d_x.toHost(ctx.stream());
+    VERIFY_IS_EQUAL(result, Vec::Zero(n));
+  }
+}
+
+// ---- BLAS-1 operator overloads (CG-style) -----------------------------------
+
+template <typename Scalar>
+void test_cg_operators(Index n) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  Vec x = Vec::Random(n);
+  Vec p = Vec::Random(n);
+  Vec tmp = Vec::Random(n);
+  Vec z = Vec::Random(n);
+  Scalar alpha(2.5);
+  Scalar beta(0.7);
+
+  // Test: x += alpha * p
+  {
+    Vec x_ref = x + alpha * p;
+    auto d_x = DeviceMatrix<Scalar>::fromHost(x);
+    auto d_p = DeviceMatrix<Scalar>::fromHost(p);
+    d_x += alpha * d_p;
+    Vec x_gpu = d_x.toHost();
+    VERIFY((x_gpu - x_ref).norm() < tol * x_ref.norm() + tol);
+  }
+
+  // Test: r -= alpha * tmp
+  {
+    Vec r = Vec::Random(n);
+    Vec r_ref = r - alpha * tmp;
+    auto d_r = DeviceMatrix<Scalar>::fromHost(r);
+    auto d_tmp = DeviceMatrix<Scalar>::fromHost(tmp);
+    d_r -= alpha * d_tmp;
+    Vec r_gpu = d_r.toHost();
+    VERIFY((r_gpu - r_ref).norm() < tol * r_ref.norm() + tol);
+  }
+
+  // Test: p = z + beta * p  (cuBLAS geam)
+  {
+    Vec p_copy = p;
+    Vec p_ref = z + beta * p_copy;
+    auto d_p = DeviceMatrix<Scalar>::fromHost(p_copy);
+    auto d_z = DeviceMatrix<Scalar>::fromHost(z);
+    d_p = d_z + beta * d_p;
+    Vec p_gpu = d_p.toHost();
+    VERIFY((p_gpu - p_ref).norm() < tol * p_ref.norm() + tol);
+  }
+
+  // Test: operator+= and operator-= with DeviceMatrix (no scalar)
+  {
+    Vec a = Vec::Random(n);
+    Vec b = Vec::Random(n);
+    Vec a_ref = a + b;
+    auto d_a = DeviceMatrix<Scalar>::fromHost(a);
+    auto d_b = DeviceMatrix<Scalar>::fromHost(b);
+    d_a += d_b;
+    VERIFY((d_a.toHost() - a_ref).norm() < tol * a_ref.norm() + tol);
+  }
+}
+
+// ---- DeviceScalar: deferred sync -------------------------------------------
+
+template <typename Scalar>
+void test_device_scalar() {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  const Index n = 256;
+  Vec a = Vec::Random(n);
+  Vec b = Vec::Random(n);
+
+  GpuContext ctx;
+  auto d_a = DeviceMatrix<Scalar>::fromHost(a, ctx.stream());
+  auto d_b = DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+
+  // dot() returns DeviceScalar — implicit conversion to Scalar syncs.
+  Scalar gpu_dot = d_a.dot(ctx, d_b);
+  Scalar cpu_dot = a.dot(b);
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(numext::abs(gpu_dot - cpu_dot) < tol * numext::abs(cpu_dot) + tol);
+
+  // squaredNorm() returns host RealScalar directly (syncs internally).
+  RealScalar gpu_sqnorm = d_a.squaredNorm(ctx);
+  RealScalar cpu_sqnorm = a.squaredNorm();
+  VERIFY(numext::abs(gpu_sqnorm - cpu_sqnorm) < tol * cpu_sqnorm + tol);
+
+  // norm() returns DeviceScalar<RealScalar> — implicit conversion syncs.
+  RealScalar gpu_norm = d_a.norm(ctx);
+  RealScalar cpu_norm = a.norm();
+  VERIFY(numext::abs(gpu_norm - cpu_norm) < tol * cpu_norm + tol);
+
+  // Convenience overloads (thread-local context).
+  GpuContext::setThreadLocal(&ctx);
+  Scalar gpu_dot2 = d_a.dot(d_b);
+  VERIFY(numext::abs(gpu_dot2 - cpu_dot) < tol * numext::abs(cpu_dot) + tol);
+  GpuContext::setThreadLocal(nullptr);
+
+  // Empty vectors: dot and norm must return zero.
+  {
+    DeviceMatrix<Scalar> d_empty(0, 1);
+    DeviceMatrix<Scalar> d_empty2(0, 1);
+    Scalar empty_dot = d_empty.dot(ctx, d_empty2);
+    VERIFY_IS_EQUAL(empty_dot, Scalar(0));
+    RealScalar empty_sqnorm = d_empty.squaredNorm(ctx);
+    VERIFY_IS_EQUAL(empty_sqnorm, RealScalar(0));
+    RealScalar empty_norm = d_empty.norm(ctx);
+    VERIFY_IS_EQUAL(empty_norm, RealScalar(0));
+  }
+}
+
+// ---- cwiseProduct -----------------------------------------------------------
+
+template <typename Scalar>
+void test_cwiseProduct() {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  const Index n = 256;
+  Vec a = Vec::Random(n);
+  Vec b = Vec::Random(n);
+  Vec ref = a.array() * b.array();
+
+  GpuContext ctx;
+  auto d_a = DeviceMatrix<Scalar>::fromHost(a, ctx.stream());
+  auto d_b = DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+  auto d_c = d_a.cwiseProduct(ctx, d_b);
+  Vec result = d_c.toHost(ctx.stream());
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((result - ref).norm() < tol * ref.norm() + tol);
+}
+
 EIGEN_DECLARE_TEST(gpu_device_matrix) {
   CALL_SUBTEST(test_default_construct());
   CALL_SUBTEST(test_empty());
@@ -242,4 +454,18 @@ EIGEN_DECLARE_TEST(gpu_device_matrix) {
   CALL_SUBTEST(test_scalar<double>());
   CALL_SUBTEST(test_scalar<std::complex<float>>());
   CALL_SUBTEST(test_scalar<std::complex<double>>());
+  CALL_SUBTEST(test_blas1<float>(256));
+  CALL_SUBTEST(test_blas1<double>(256));
+  CALL_SUBTEST(test_blas1<std::complex<float>>(256));
+  CALL_SUBTEST(test_blas1<std::complex<double>>(256));
+  CALL_SUBTEST(test_cg_operators<float>(256));
+  CALL_SUBTEST(test_cg_operators<double>(256));
+  CALL_SUBTEST(test_cg_operators<std::complex<float>>(256));
+  CALL_SUBTEST(test_cg_operators<std::complex<double>>(256));
+  CALL_SUBTEST(test_device_scalar<float>());
+  CALL_SUBTEST(test_device_scalar<double>());
+  CALL_SUBTEST(test_device_scalar<std::complex<float>>());
+  CALL_SUBTEST(test_device_scalar<std::complex<double>>());
+  CALL_SUBTEST(test_cwiseProduct<float>());
+  CALL_SUBTEST(test_cwiseProduct<double>());
 }