diff --git a/src/MatrixOptInterface.jl b/src/MatrixOptInterface.jl
index 951fde2..145daf2 100644
--- a/src/MatrixOptInterface.jl
+++ b/src/MatrixOptInterface.jl
@@ -65,7 +65,6 @@ end
 
 @enum VariableType CONTINUOUS INTEGER BINARY
 
-include("sparse_matrix.jl")
 include("conic_form.jl")
 include("matrix_input.jl")
 #include("change_form.jl")
diff --git a/src/sparse_matrix.jl b/src/sparse_matrix.jl
deleted file mode 100644
index 2c4354c..0000000
--- a/src/sparse_matrix.jl
+++ /dev/null
@@ -1,108 +0,0 @@
-# Copyright (c) 2019: Joaquim Dias Garcia, and contributors
-#
-# Use of this source code is governed by an MIT-style license that can be found
-# in the LICENSE.md file or at https://opensource.org/licenses/MIT.
-
-abstract type AbstractIndexing end
-
-struct ZeroBasedIndexing <: AbstractIndexing end
-
-struct OneBasedIndexing <: AbstractIndexing end
-
-first_index(::ZeroBasedIndexing) = 0
-
-first_index(::OneBasedIndexing) = 1
-
-shift(x, ::ZeroBasedIndexing, ::ZeroBasedIndexing) = x
-
-shift(x::Integer, ::ZeroBasedIndexing, ::OneBasedIndexing) = x + 1
-
-shift(x::Array{<:Integer}, ::ZeroBasedIndexing, ::OneBasedIndexing) = x .+ 1
-
-shift(x::Integer, ::OneBasedIndexing, ::ZeroBasedIndexing) = x - 1
-
-shift(x, ::OneBasedIndexing, ::OneBasedIndexing) = x
-
-mutable struct SparseMatrixCSRtoCSC{Tv,Ti<:Integer,I<:AbstractIndexing}
-    indexing::I
-    m::Int # Number of rows
-    n::Int # Number of columns
-    colptr::Vector{Ti}
-    rowval::Vector{Ti}
-    nzval::Vector{Tv}
-    function SparseMatrixCSRtoCSC{Tv,Ti,I}(n) where {Tv,Ti<:Integer,I}
-        A = new{Tv,Ti,I}()
-        A.n = n
-        A.colptr = zeros(Ti, n + 1)
-        return A
-    end
-end
-
-function allocate_nonzeros(A::SparseMatrixCSRtoCSC{Tv,Ti}) where {Tv,Ti}
-    for i in 3:length(A.colptr)
-        A.colptr[i] += A.colptr[i-1]
-    end
-    A.rowval = Vector{Ti}(undef, A.colptr[end])
-    A.nzval = Vector{Tv}(undef, A.colptr[end])
-    return
-end
-
-function final_touch(A::SparseMatrixCSRtoCSC)
-    for i in length(A.colptr):-1:2
-        A.colptr[i] = shift(A.colptr[i-1], ZeroBasedIndexing(), A.indexing)
-    end
-    A.colptr[1] = first_index(A.indexing)
-    return
-end
-
-function _allocate_terms(colptr, indexmap, terms)
-    for term in terms
-        colptr[indexmap[term.scalar_term.variable].value+1] += 1
-    end
-    return
-end
-
-function allocate_terms(A::SparseMatrixCSRtoCSC, indexmap, func)
-    return _allocate_terms(A.colptr, indexmap, func.terms)
-end
-
-function _load_terms(colptr, rowval, nzval, indexmap, terms, offset)
-    for term in terms
-        ptr = colptr[indexmap[term.scalar_term.variable].value] += 1
-        rowval[ptr] = offset + term.output_index
-        nzval[ptr] = -term.scalar_term.coefficient
-    end
-    return
-end
-
-function load_terms(A::SparseMatrixCSRtoCSC, indexmap, func, offset)
-    return _load_terms(
-        A.colptr,
-        A.rowval,
-        A.nzval,
-        indexmap,
-        func.terms,
-        shift(offset, OneBasedIndexing(), A.indexing),
-    )
-end
-
-"""
-    Base.convert(::Type{SparseMatrixCSC{Tv, Ti}}, A::SparseMatrixCSRtoCSC{Tv, Ti, I}) where {Tv, Ti, I}
-
-Converts `A` to a `SparseMatrixCSC`. Note that the field `A.nzval` is **not
-copied** so if `A` is modified after the call of this function, it can still
-affect the value returned. Moreover, if `I` is `OneBasedIndexing`, `colptr`
-and `rowval` are not copied either, i.e., the conversion is allocation-free.
-"""
-function Base.convert(
-    ::Type{SparseMatrixCSC{Tv,Ti}},
-    A::SparseMatrixCSRtoCSC{Tv,Ti},
-) where {Tv,Ti}
-    return SparseMatrixCSC{Tv,Ti}(
-        A.m,
-        A.n,
-        shift(A.colptr, A.indexing, OneBasedIndexing()),
-        shift(A.rowval, A.indexing, OneBasedIndexing()),
-        A.nzval,
-    )
-end
diff --git a/test/conic_form.jl b/test/conic_form.jl
index dbebee1..3b2e198 100644
--- a/test/conic_form.jl
+++ b/test/conic_form.jl
@@ -11,25 +11,6 @@ function _test_matrix_equal(A::SparseMatrixCSC, B::SparseMatrixCSC)
     @test A.colptr == B.colptr
 end
 
-function _test_matrix_equal(
-    A::MatOI.SparseMatrixCSRtoCSC{Tv,Ti,I},
-    B::SparseMatrixCSC,
-) where {Tv,Ti,I}
-    @test A.m == B.m
-    @test A.n == B.n
-    @test A.nzval ≈ B.nzval atol = ATOL rtol = RTOL
-    if I <: MatOI.OneBasedIndexing
-        @test A.rowval == B.rowval
-        @test A.colptr == B.colptr
-    else
-        @test A.rowval == B.rowval .- 1
-        @test A.colptr == B.colptr .- 1
-    end
-    sA = convert(typeof(B), A)
-    @test typeof(sA) == typeof(B)
-    return _test_matrix_equal(sA, B)
-end
-
 # _psd1test: https://github.com/jump-dev/MathOptInterface.jl/blob/master/src/Test/contconic.jl#L2417
 function psd1(::Type{T}, ::Type{I}) where {T,I}
     # We use `MockOptimizer` to have indices xor'ed so that it tests that we don't assumes they are `1:n`.
@@ -93,7 +74,7 @@ function psd1(::Type{T}, ::Type{I}) where {T,I}
 
     conic_form = MatOI.GeometricConicForm{
         T,
-        MatOI.SparseMatrixCSRtoCSC{T,Int,I},
+        MOI.Utilities.MutableSparseMatrixCSC{T,Int,I},
         Vector{T},
     }([
         MOI.PositiveSemidefiniteConeTriangle,
@@ -319,7 +300,7 @@ function psd2(
 end
 
 @testset "PSD $T, $I" for T in [Float64, BigFloat],
-    I in [MatOI.ZeroBasedIndexing, MatOI.OneBasedIndexing]
+    I in [MOI.Utilities.ZeroBasedIndexing, MOI.Utilities.OneBasedIndexing]
 
     psd1(T, I)
     psd2(T, I)