diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 050cf586..8989cfa8 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -52,6 +52,9 @@ if (KOKKOS)
     add_definitions(-DHAVE_THREADS=1)
   endif()
 
+  add_executable(testsetval test_set_values.cpp)
+  target_link_libraries(testsetval ${LINKING_LIBRARIES})
+
   add_executable(mtestkokkos main_kokkos.cpp)
   target_link_libraries(mtestkokkos ${LINKING_LIBRARIES})
 
@@ -108,8 +111,10 @@ add_subdirectory(sparsetests)
 include_directories(test_rocm)
 add_subdirectory(test_rocm)
 
-include_directories(laplaceMPI)
-add_subdirectory(laplaceMPI)
+if (MPI)
+   include_directories(laplaceMPI)
+   add_subdirectory(laplaceMPI)
+endif()
 
 #include_directories(phaseField/srcKokkosVerbose)
 #add_subdirectory(phaseField/srcKokkosVerbose)
diff --git a/examples/mtr-kokkos-simple.cpp b/examples/mtr-kokkos-simple.cpp
index 4cf79c9f..b6a9d11b 100644
--- a/examples/mtr-kokkos-simple.cpp
+++ b/examples/mtr-kokkos-simple.cpp
@@ -126,8 +126,12 @@ int main(int argc, char *argv[]) {
 
         // Matrix examples following the Fortran index convention,
         // indicies go from 1 to N, first index varies the fastest
-        FMatrixDevice <real_t> matrix1D(10);    // declare and allocate a 1D matrix of size 10
-        FMatrixDevice <real_t> matrix2D(10,10); // declare and allocate a 2D matrix with sizes of 10 x 10
+        FMatrixDevice <real_t> matrix1D(10, "1D_FMatrix");    // declare and allocate a 1D matrix of size 10
+        FMatrixDevice <real_t> matrix2D(10,10, "2D_FMatrix"); // declare and allocate a 2D matrix with sizes of 10 x 10
+
+        std::cout<< "Name of 1D Matrix = "<<matrix1D.get_name()<<std::endl;
+        std::cout<< "Name of 2D Matrix = "<<matrix2D.get_name()<<std::endl;
+
 
         FMatrixDevice <real_t> matrix3D;        // declare variable and allocate sizes and dimensions later
         matrix3D = FMatrixDevice <real_t> (10,10,10); // allocate dimensions and sizes 
diff --git a/examples/test_set_values.cpp b/examples/test_set_values.cpp
new file mode 100644
index 00000000..b02a92d1
--- /dev/null
+++ b/examples/test_set_values.cpp
@@ -0,0 +1,281 @@
+/**********************************************************************************************
+ � 2020. Triad National Security, LLC. All rights reserved.
+ This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
+ National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
+ Department of Energy/National Nuclear Security Administration. All rights in the program are
+ reserved by Triad National Security, LLC, and the U.S. Department of Energy/National Nuclear
+ Security Administration. The Government is granted for itself and others acting on its behalf a
+ nonexclusive, paid-up, irrevocable worldwide license in this material to reproduce, prepare
+ derivative works, distribute copies to the public, perform publicly and display publicly, and
+ to permit others to do so.
+ This program is open source under the BSD-3 License.
+ 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.
+ 3.  Neither the name of the copyright holder nor the names of its contributors may be used
+ to endorse or promote products derived from this software without specific prior
+ written permission.
+ 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 HOLDER 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.
+ **********************************************************************************************/
+#include <stdio.h>
+#include "matar.h"
+
+using namespace mtr; // matar namespace
+
+int main()
+{
+    // DENSE
+    int dim0 = 2;
+    int dim1 = 3;
+    int dim2 = 2;
+
+    printf("HOST TYPES");
+
+    FArray <double> testing (dim0,dim1,dim2);
+    ViewFArray <double> testing2 (&testing(0,0,0),3,2);
+    testing.set_values(1.3);
+    testing2.set_values(2.6);
+    printf("ViewFArray set_values 2.6 writing over FArray set_values 1.3.\n");
+    for (int i = 0; i < dim2; i++) {
+        for (int j = 0; j < dim1; j++) {
+            for (int k = 0; k < dim0; k++) {
+                printf("%.1f  ", testing(k,j,i));
+            }
+        }
+    } 
+    printf("\n");
+    for (int i = 0; i < dim2; i++) {
+        for (int j = 0; j < dim1; j++) {
+            printf("%.1f  ", testing2(j,i));
+        }
+    }
+    printf("\n");
+    CArray <double> testing3 (dim0,dim1,dim2);
+    ViewCArray <double> testing4 (&testing3(0,0,0),3,2);
+    testing3.set_values(1.3);
+    testing4.set_values(2.6);
+    printf("ViewCArray set_values 2.6 writing over CArray set_values 1.3.\n");
+    for (int i = 0; i < dim0; i++) {
+        for (int j = 0; j < dim1; j++) {
+            for (int k = 0; k < dim2; k++) {
+                printf("%.1f  ", testing3(i,j,k));
+            }
+        }
+    } 
+    printf("\n");
+    for (int i = 0; i < dim1; i++) {
+        for (int j = 0; j < dim2; j++) {
+            printf("%.1f  ", testing4(i,j));
+        }
+    }
+    printf("\n");
+    CMatrix <double> testing5 (dim0,dim1,dim2);
+    ViewCMatrix <double> testing6 (&testing5(1,1,1),3,2);
+    testing5.set_values(1.3);
+    testing6.set_values(2.6);
+    printf("ViewCMatrix set_values 2.6 writing over CMatrix set_values 1.3.\n");
+    for (int i = 1; i < dim0+1; i++) {
+        for (int j = 1; j < dim1+1; j++) {
+            for (int k = 1; k < dim2+1; k++) {
+                printf("%.1f  ", testing5(i,j,k));
+            }
+        }
+    } 
+    printf("\n");
+    for (int i = 1; i < dim1+1; i++) {
+        for (int j = 1; j < dim2+1; j++) {
+            printf("%.1f  ", testing6(i,j));
+        }
+    }
+    printf("\n");
+    FMatrix <double> testing7 (dim0,dim1,dim2);
+    ViewFMatrix <double> testing8 (&testing7(1,1,1),3,2);
+    testing7.set_values(1.3);
+    testing8.set_values(2.6);
+    printf("ViewFMatrix set_values 2.6 writing over FMatrix set_values 1.3.\n");
+    for (int i = 1; i < dim2+1; i++) {
+        for (int j = 1; j < dim1+1; j++) {
+            for (int k = 1; k < dim0+1; k++) {
+                printf("%.1f  ", testing7(k,j,i));
+            }
+        }
+    } 
+    printf("\n");
+    for (int i = 1; i < dim2+1; i++) {
+        for (int j = 1; j < dim1+1; j++) {
+            printf("%.1f  ", testing8(j,i));
+        }
+    }
+    printf("\n");
+
+    // RAGGEDS
+    CArray <size_t> stridesright (3);
+    stridesright(0) = 2;
+    stridesright(1) = 3;
+    stridesright(2) = 2;
+    RaggedRightArray <double> righttest (stridesright);
+    righttest.set_values(1.35);
+    printf("RaggedRightArray set to values of 1.35\n");
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < stridesright(i); j++) {
+            printf("%.2f  ", righttest(i,j));
+        }
+    }
+    printf("\n");
+    CArray <size_t> stridesdown (4);
+    stridesdown(0) = 2;
+    stridesdown(1) = 3;
+    stridesdown(2) = 2;
+    stridesdown(3) = 1;
+    RaggedDownArray <double> downtest (stridesdown);
+    downtest.set_values(2.55);
+    printf("RaggedDownArray set to values of 2.55\n");
+    for (int i = 0; i < 4; i++) {
+        for (int j = 0; j < stridesdown(i); j++) {
+            printf("%.2f  ", downtest(j,i));
+        }
+    }
+    printf("\n");
+    DynamicRaggedRightArray <double> dynright (3,4);
+    dynright.stride(0) = 1;
+    dynright.stride(1) = 3;
+    dynright.stride(2) = 2;
+    dynright.set_values(2.14);
+    dynright.set_values_sparse(1.35);
+    printf("The values within the populated strides of the DynamicRaggedRight are set to 1.35 and the data in the rest of the array is set to 2.14.\n");
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 4; j++) {
+            printf("%.2f  ", dynright(i,j));
+        }
+        printf("\n");
+    }
+    DynamicRaggedDownArray <double> dyndown (3,4);
+    dyndown.stride(0) = 1;
+    dyndown.stride(1) = 3;
+    dyndown.stride(2) = 2;
+    dyndown.stride(3) = 1;
+    dyndown.set_values(2.14);
+    dyndown.set_values_sparse(1.35);
+    printf("The values within the populated strides of the DynamicRaggedDown are set to 1.35 and the data in the rest of the array is set to 2.14.\n");
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 4; j++) {
+            printf("%.2f  ", dyndown(i,j));
+        }
+        printf("\n");
+    } 
+    printf("Ragged Right Array of Vectors, CSCArray, and CSRArray are not currently tested in this file as of 8/6/24.\n");
+
+
+    printf("DUAL TYPES");
+    Kokkos::initialize();
+    {
+        DFArrayKokkos <double> DFAtest (2, 3, 4);
+        DViewFArrayKokkos <double> DVFAtest (&DFAtest(0, 0, 0), 3, 4);
+        DFAtest.set_values(1.25);
+        DVFAtest.set_values(2.34);
+        printf("DViewFArrayKokkos set_values 2.34 writing over DFArrayKokkos set_values 1.25.\n");
+        FOR_ALL(i, 0, 4,
+                j, 0, 3,
+                k, 0, 2, {
+                printf("%.2f ", DFAtest(k,j,i));
+        });
+        printf("\n");
+        FOR_ALL(i, 0, 4,
+                j, 0, 3,{
+                printf("%.2f ", DVFAtest(j,i));
+        });
+        printf("\n");
+        DFMatrixKokkos <double> DFMtest (2, 3, 4);
+        DViewFMatrixKokkos <double> DVFMtest (&DFMtest(1, 1, 1), 3, 4);
+        DFMtest.set_values(1.33);
+        DVFMtest.set_values(3.24);
+        printf("DViewFMatrixKokkos set_values 3.24 writing over DFMatrixKokkos set_values 1.33.\n");
+        FOR_ALL(i, 1, 5,
+                j, 1, 4,
+                k, 1, 3, {
+                printf("%.2f ", DFMtest(k,j,i));
+        });
+        printf("\n");
+        FOR_ALL(i, 1, 5,
+                j, 1, 4,{
+                printf("%.2f ", DVFMtest(j,i));
+        });
+        printf("\n");
+        DCArrayKokkos <double> DCAtest (2, 3, 4);
+        DViewCArrayKokkos <double> DVCAtest (&DCAtest(0, 0, 0), 3, 4);
+        DCAtest.set_values(1.53);
+        DVCAtest.set_values(2.33);
+        printf("DViewCArrayKokkos set_values 2.33 writing over DCArrayKokkos set_values 1.53.\n");
+        FOR_ALL(i, 0, 4,
+                j, 0, 3,
+                k, 0, 2, {
+                printf("%.2f ", DCAtest(k,j,i));
+        });
+        printf("\n");
+        FOR_ALL(i, 0, 4,
+                j, 0, 3,{
+                printf("%.2f ", DVCAtest(j,i));
+        });
+        printf("\n");
+        DCMatrixKokkos <double> DCMtest (2, 3, 4);
+        DViewCMatrixKokkos <double> DVCMtest (&DCMtest(1, 1, 1), 3, 4);
+        DCMtest.set_values(1.77);
+        DVCMtest.set_values(2.17);
+        printf("DViewCMatrixKokkos set_values 2.17 writing over DCMatrixKokkos set_values 1.77.\n");
+        FOR_ALL(i, 1, 5,
+                j, 1, 4,
+                k, 1, 3, {
+                printf("%.2f ", DCMtest(k,j,i));
+        });
+        printf("\n");
+        FOR_ALL(i, 1, 5,
+                j, 1, 4,{
+                printf("%.2f ", DVCMtest(j,i));
+        });
+        printf("\n");
+
+        DynamicRaggedRightArrayKokkos <double> dynrightK (3,4);
+        dynrightK.stride(0) = 1;
+        dynrightK.stride(1) = 3;
+        dynrightK.stride(2) = 2;
+        dynrightK.set_values(2.14);
+        dynrightK.set_values_sparse(1.35);
+        printf("The values within the populated strides of the DynamicRaggedRight are set to 1.35 and the data in the rest of the array is set to 2.14.\n");
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 4; j++) {
+                printf("%.2f  ", dynrightK(i,j));
+            }
+            printf("\n");
+        }
+        DynamicRaggedDownArrayKokkos <double> dyndownK (3,4);
+        dyndownK.stride(0) = 1;
+        dyndownK.stride(1) = 3;
+        dyndownK.stride(2) = 2;
+        dyndownK.stride(3) = 1;
+        dyndownK.set_values(2.14);
+        dyndownK.set_values_sparse(1.35);
+        printf("The values within the populated strides of the DynamicRaggedDown are set to 1.35 and the data in the rest of the array is set to 2.14.\n");
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 4; j++) {
+                printf("%.2f  ", dyndownK(i,j));
+            }
+            printf("\n");
+        } 
+
+    }
+    Kokkos::finalize();    
+}
diff --git a/examples/test_set_values.cpp:Zone.Identifier b/examples/test_set_values.cpp:Zone.Identifier
new file mode 100644
index 00000000..a45e1ac4
--- /dev/null
+++ b/examples/test_set_values.cpp:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/src/include/host_types.h b/src/include/host_types.h
index 296e31eb..3a15a589 100644
--- a/src/include/host_types.h
+++ b/src/include/host_types.h
@@ -156,6 +156,9 @@ class FArray {
     
     //return pointer
     T* pointer() const;
+
+    // set values to input
+    void set_values(T val);
     
     // deconstructor
     ~FArray ();
@@ -469,6 +472,15 @@ inline T* FArray<T>::pointer() const {
     return array_.get();
 }
 
+
+template <typename T>
+void FArray<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
+
 //delete FArray
 template <typename T>
 FArray<T>::~FArray(){}
@@ -583,6 +595,9 @@ class ViewFArray {
     // return array order (rank)
     size_t order() const;
 
+    // set values to input
+    void set_values(T val);
+
     // return pointer
     T* pointer() const;
     
@@ -874,6 +889,13 @@ inline T* ViewFArray<T>::pointer() const {
     return array_;
 }
 
+template <typename T>
+void ViewFArray<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
 //---end of ViewFArray class definitions---
 
 
@@ -980,6 +1002,9 @@ class FMatrix {
     //return pointer
     T* pointer() const;
 
+    // set values to input
+    void set_values(T val);
+
     // Deconstructor
     ~FMatrix ();
 
@@ -1291,6 +1316,13 @@ inline T* FMatrix<T>::pointer() const{
     return matrix_.get();
 }
 
+template <typename T>
+void FMatrix<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        matrix_[i] = val;
+    }
+}
+
 template <typename T>
 FMatrix<T>::~FMatrix() {}
 
@@ -1405,6 +1437,9 @@ class ViewFMatrix {
     // return matrix order (rank)
     size_t order() const;
 
+    // set values to input
+    void set_values(T val);
+
     // return pointer
     T* pointer() const;
     
@@ -1694,6 +1729,14 @@ template <typename T>
 inline T* ViewFMatrix<T>::pointer() const {
     return matrix_;
 }
+
+template <typename T>
+void ViewFMatrix<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        matrix_[i] = val;
+    }
+}
+
 //-----end ViewFMatrix-----
 
 
@@ -1802,6 +1845,9 @@ class CArray {
     //return pointer
     T* pointer() const;
 
+    // set values to input
+    void set_values(T val);
+
     // Deconstructor
     ~CArray ();
 
@@ -2125,6 +2171,13 @@ inline T* CArray<T>::pointer() const{
     return array_.get();
 }
 
+template <typename T>
+void CArray<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
 //destructor
 template <typename T>
 CArray<T>::~CArray() {}
@@ -2238,6 +2291,9 @@ class ViewCArray {
     // return array order (rank)
     size_t order() const;
 
+    // set values to input
+    void set_values(T val);
+
     // return pointer
     T* pointer() const;
     
@@ -2549,6 +2605,13 @@ inline T* ViewCArray<T>::pointer() const {
     return array_;
 }
 
+template <typename T>
+void ViewCArray<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
 //---end of ViewCArray class definitions----
 
 
@@ -2655,6 +2718,9 @@ class CMatrix {
     //return pointer
     T* pointer() const;
     
+    // set values to input
+    void set_values(T val);
+
     // deconstructor
     ~CMatrix( );
         
@@ -2973,6 +3039,13 @@ inline T* CMatrix<T>::pointer() const{
     return matrix_.get();
 }
 
+template <typename T>
+void CMatrix<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        matrix_[i] = val;
+    }
+}
+
 // Destructor
 template <typename T>
 CMatrix<T>::~CMatrix(){}
@@ -3088,6 +3161,9 @@ class ViewCMatrix {
     // return array order (rank)
     size_t order() const;
 
+    // set values to input
+    void set_values(T val);
+
     // return pointer
     T* pointer() const;
     
@@ -3383,6 +3459,13 @@ inline T* ViewCMatrix<T>::pointer() const {
     return matrix_;
 }
 
+template <typename T>
+void ViewCMatrix<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        matrix_[i] = val;
+    }
+}
+
 
 //----end of ViewCMatrix class definitions----
 
@@ -3444,6 +3527,9 @@ class RaggedRightArray {
 
     RaggedRightArray& operator= (const RaggedRightArray &temp);
 
+    // set values to input
+    void set_values(T val);
+
     // Destructor
     ~RaggedRightArray ( );
 }; // End of RaggedRightArray
@@ -3629,6 +3715,13 @@ inline size_t* RaggedRightArray<T>::get_starts() const{
     return start_index_.get();
 }
 
+template <typename T>
+void RaggedRightArray<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
 // Destructor
 template <typename T>
 RaggedRightArray<T>::~RaggedRightArray () {}
@@ -3696,6 +3789,9 @@ class RaggedRightArrayofVectors {
 
     RaggedRightArrayofVectors& operator= (const RaggedRightArrayofVectors &temp);
 
+    // set values to input
+    void set_values(T val);
+
     // Destructor
     ~RaggedRightArrayofVectors ( );
 }; // End of RaggedRightArray
@@ -3887,6 +3983,13 @@ inline size_t* RaggedRightArrayofVectors<T>::get_starts() const{
     return start_index_.get();
 }
 
+template <typename T>
+void RaggedRightArrayofVectors<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
 // Destructor
 template <typename T>
 RaggedRightArrayofVectors<T>::~RaggedRightArrayofVectors () {}
@@ -3949,6 +4052,9 @@ class RaggedDownArray {
     //overload = operator
     RaggedDownArray& operator= (const RaggedDownArray &temp);
 
+    // set values to input
+    void set_values(T val);
+
     //destructor
     ~RaggedDownArray();
 
@@ -3966,7 +4072,7 @@ RaggedDownArray<T>::RaggedDownArray() {
 template <typename T>
 RaggedDownArray<T>::RaggedDownArray( CArray <size_t> &strides_array) {
     // Length of stride array
-    //dim2_ = strides_array.size();
+    dim2_ = strides_array.size();
 
     // Create and initialize startding indices
     start_index_ = std::shared_ptr <size_t[]> (new size_t[(dim2_ + 1)]); // note the dim2+1
@@ -4131,6 +4237,13 @@ inline size_t* RaggedDownArray<T>::get_starts() const{
     return start_index_.get();
 }
 
+template <typename T>
+void RaggedDownArray<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
 // Destructor
 template <typename T>
 RaggedDownArray<T>::~RaggedDownArray() {}
@@ -4180,6 +4293,12 @@ class DynamicRaggedRightArray {
     // Overload copy assignment operator
     DynamicRaggedRightArray& operator= (const DynamicRaggedRightArray &temp);
     
+    // set values of array indices
+    void set_values(T val);
+
+    // set values to only previously non-empty indices based upon stride value
+    void set_values_sparse(T val);
+
     // Destructor
     ~DynamicRaggedRightArray ();
 };
@@ -4275,6 +4394,22 @@ inline T* DynamicRaggedRightArray<T>::pointer() const{
     return array_.get();
 }
 
+template <typename T>
+void DynamicRaggedRightArray<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
+template <typename T>
+void DynamicRaggedRightArray<T>::set_values_sparse(T val) {
+    for(int i = 0; i < dim1_; i++) {
+        for(int j = 0; j < stride_[i]; j++) {
+            array_[dim2_*i+j] = val;
+        }
+    }
+}
+
 // Destructor
 template <typename T>
 DynamicRaggedRightArray<T>::~DynamicRaggedRightArray() {}
@@ -4324,6 +4459,12 @@ class DynamicRaggedDownArray {
 
     //return pointer
     T* pointer() const;
+
+    // set values of indices
+    void set_values(T val);
+
+    // set values to input
+    void set_values_sparse(T val);
     
     // Destructor
     ~DynamicRaggedDownArray ();
@@ -4422,6 +4563,22 @@ inline T* DynamicRaggedDownArray<T>::pointer() const{
     return array_.get();
 }
 
+template <typename T>
+void DynamicRaggedDownArray<T>::set_values(T val) {
+    for(int i = 0; i < length_; i++) {
+        array_[i] = val;
+    }
+}
+
+template <typename T>
+void DynamicRaggedDownArray<T>::set_values_sparse(T val) {
+    for(int j = 0; j < dim2_; j++) {
+        for(int i = 0; i < stride_[j]; i++) {
+            array_[dim1_*j+i] = val;
+        }
+    }
+}
+
 // Destructor
 template <typename T>
 DynamicRaggedDownArray<T>::~DynamicRaggedDownArray() {}
@@ -4572,6 +4729,10 @@ class CSRArray {
     int toCSC(CArray<T> &array, CArray<size_t> &start_index, CArray<size_t> &row_index);
     
     void to_dense(CArray<T>& A);
+
+    // set values to input
+    void set_values(T val);
+
     //destructor
    ~CSRArray();
 
@@ -4850,6 +5011,13 @@ int CSRArray<T>::toCSC(CArray<T> &data, CArray<size_t> &col_ptrs, CArray<size_t>
     return 0;
 }
 
+template <typename T>
+void CSRArray<T>::set_values(T val) {
+    for(int i = 0; i < nnz_; i++) {
+        array_[i] = val;
+    }
+}
+
 template <typename T>
 CSRArray<T>::~CSRArray() {}
 
@@ -4987,6 +5155,10 @@ class CSCArray
       // Convertor
       int toCSR(CArray<T> &data, CArray<size_t> &row_ptrs, CArray<size_t> &col_ptrs);
       void to_dense(FArray<T> &A);
+
+      // set values to input
+      void set_values(T val);
+
       // destructor
       ~CSCArray();
 };
@@ -5204,6 +5376,13 @@ int CSCArray<T>::toCSR(CArray<T> &data, CArray<size_t> &col_ptrs, CArray<size_t>
     return 0;
 }
 
+template <typename T>
+void CSCArray<T>::set_values(T val) {
+    for(int i = 0; i < nnz_; i++) {
+        array_[i] = val;
+    }
+}
+
 template <typename T>
 CSCArray<T>::~CSCArray() {}
 
diff --git a/src/include/kokkos_types.h b/src/include/kokkos_types.h
index e7bf319b..ff70bcfa 100644
--- a/src/include/kokkos_types.h
+++ b/src/include/kokkos_types.h
@@ -238,6 +238,10 @@ class FArrayKokkos {
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view() const;
 
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
     // Destructor
     KOKKOS_INLINE_FUNCTION
     ~FArrayKokkos();
@@ -529,6 +533,14 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> FArrayKokkos<T,Layout,ExecSpac
     return this_array_;
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string FArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_array_.label();
+}
+
+
 // set values of array
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
@@ -629,6 +641,10 @@ class ViewFArrayKokkos {
     KOKKOS_INLINE_FUNCTION
     T* pointer() const;
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
     KOKKOS_INLINE_FUNCTION
     ~ViewFArrayKokkos();
 
@@ -878,6 +894,14 @@ T* ViewFArrayKokkos<T>::pointer() const {
     return this_array_;
 }
 
+template <typename T>
+KOKKOS_INLINE_FUNCTION
+void ViewFArrayKokkos<T>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_array_(i) = val;
+    });
+}
+
 template <typename T>
 KOKKOS_INLINE_FUNCTION
 ViewFArrayKokkos<T>::~ViewFArrayKokkos() {}
@@ -972,6 +996,10 @@ class FMatrixKokkos {
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view() const;
 
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
     KOKKOS_INLINE_FUNCTION
     ~FMatrixKokkos();
 
@@ -1246,6 +1274,14 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> FMatrixKokkos<T,Layout,ExecSpa
     return this_matrix_;
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string FMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_matrix_.label();
+}
+
+
 // set values of array
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
@@ -1347,6 +1383,10 @@ class ViewFMatrixKokkos {
     KOKKOS_INLINE_FUNCTION
     T* pointer() const;
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
     KOKKOS_INLINE_FUNCTION
     ~ViewFMatrixKokkos();
     
@@ -1599,6 +1639,14 @@ T* ViewFMatrixKokkos<T>::pointer() const {
     return this_matrix_;
 }
 
+template <typename T>
+KOKKOS_INLINE_FUNCTION
+void ViewFMatrixKokkos<T>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_matrix_(i) = val;
+    });
+}
+
 template <typename T>
 KOKKOS_INLINE_FUNCTION
 ViewFMatrixKokkos<T>::~ViewFMatrixKokkos() {}
@@ -1704,6 +1752,16 @@ class DFArrayKokkos {
     // Method that update device view
     void update_device();
 
+
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~DFArrayKokkos ();
@@ -1995,6 +2053,21 @@ void DFArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::update_device() {
     this_array_.template sync<typename TArray1D::execution_space>();
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DFArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_array_.view_host().label();
+}
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DFArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_array_.h_view(i) = val;
+    });
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 DFArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::~DFArrayKokkos() {}
@@ -2107,6 +2180,16 @@ class DViewFArrayKokkos {
     // Method that update device view
     void update_device();
 
+
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~DViewFArrayKokkos ();
@@ -2445,6 +2528,21 @@ void DViewFArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::update_device() {
     deep_copy(this_array_, this_array_host_);
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DViewFArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_array_.label();
+}
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DViewFArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_array_host_(i) = val;
+    });
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 DViewFArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::~DViewFArrayKokkos() {}
@@ -2547,6 +2645,16 @@ class DFMatrixKokkos {
     // Method that update device view
     void update_device();
 
+
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~DFMatrixKokkos ();
@@ -2838,6 +2946,21 @@ void DFMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::update_device() {
     this_matrix_.template sync<typename TArray1D::execution_space>();
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DFMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_matrix_.view_host().label();
+}
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DFMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_matrix_.h_view(i) = val;
+    });
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 DFMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::~DFMatrixKokkos() {}
@@ -2945,6 +3068,16 @@ class DViewFMatrixKokkos {
     // Method that update device view
     void update_device();
 
+
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~DViewFMatrixKokkos ();
@@ -3273,6 +3406,22 @@ void DViewFMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::update_device() {
     deep_copy(this_matrix_, this_matrix_host_);
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DViewFMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_matrix_.label();
+}
+
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DViewFMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_matrix_host_(i) = val;
+    });
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 DViewFMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::~DViewFMatrixKokkos() {}
@@ -3369,6 +3518,10 @@ class CArrayKokkos {
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view() const;
 
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~CArrayKokkos ();
@@ -3640,6 +3793,13 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> CArrayKokkos<T,Layout,ExecSpac
     return this_array_;
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string CArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_array_.label();
+}
+
 // set values of array
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
@@ -3739,6 +3899,10 @@ class ViewCArrayKokkos {
     KOKKOS_INLINE_FUNCTION
     T* pointer() const;
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
     KOKKOS_INLINE_FUNCTION
     ~ViewCArrayKokkos();
     
@@ -3986,6 +4150,14 @@ T* ViewCArrayKokkos<T>::pointer() const {
     return this_array_;
 }
 
+template <typename T>
+KOKKOS_INLINE_FUNCTION
+void ViewCArrayKokkos<T>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_array_(i) = val;
+    });
+}
+
 template <typename T>
 KOKKOS_INLINE_FUNCTION
 ViewCArrayKokkos<T>::~ViewCArrayKokkos() {}
@@ -4079,6 +4251,10 @@ class CMatrixKokkos {
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view() const;
 
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
     KOKKOS_INLINE_FUNCTION
     ~CMatrixKokkos();
 
@@ -4356,6 +4532,13 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> CMatrixKokkos<T,Layout,ExecSpa
     return this_matrix_;
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string CMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_matrix_.label();
+}
+
 // set values of array
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
@@ -4451,6 +4634,10 @@ class ViewCMatrixKokkos {
     KOKKOS_INLINE_FUNCTION
     T* pointer() const;
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
     KOKKOS_INLINE_FUNCTION
     ~ViewCMatrixKokkos();
 
@@ -4695,6 +4882,14 @@ T* ViewCMatrixKokkos<T>::pointer() const {
     return this_matrix_;
 }
 
+template <typename T>
+KOKKOS_INLINE_FUNCTION
+void ViewCMatrixKokkos<T>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_matrix_(i) = val;
+    });
+}
+
 template <typename T>
 KOKKOS_INLINE_FUNCTION
 ViewCMatrixKokkos<T>::~ViewCMatrixKokkos() {}
@@ -4797,12 +4992,20 @@ class DCArrayKokkos {
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_dual_view() const;
 
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
     // Method that update host view
     void update_host();
 
     // Method that update device view
     void update_device();
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~DCArrayKokkos ();
@@ -5086,6 +5289,13 @@ Kokkos::DualView <T*, Layout, ExecSpace, MemoryTraits> DCArrayKokkos<T,Layout,Ex
   return this_array_;
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_array_.view_host().label();
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 void DCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::update_host() {
 
@@ -5100,6 +5310,14 @@ void DCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::update_device() {
     this_array_.template sync<typename TArray1D::execution_space>();
 }
 
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_array_.h_view(i) = val;
+    });
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 DCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::~DCArrayKokkos() {}
@@ -5208,6 +5426,16 @@ class DViewCArrayKokkos {
     // Method that update device view
     void update_device();
 
+
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~DViewCArrayKokkos ();
@@ -5553,6 +5781,20 @@ void DViewCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::update_device() {
     deep_copy(this_array_, this_array_host_);
 }
 
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DViewCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_array_host_(i) = val;
+    });
+}
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DViewCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_array_.label();
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 DViewCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::~DViewCArrayKokkos() {}
@@ -5655,6 +5897,14 @@ class DCMatrixKokkos {
     // Method that update device view
     void update_device();
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~DCMatrixKokkos ();
@@ -5947,6 +6197,21 @@ void DCMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::update_device() {
     this_matrix_.template sync<typename TArray1D::execution_space>();
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DCMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_matrix_.view_host().label();
+}
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DCMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_matrix_.h_view(i) = val;
+    });
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 DCMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::~DCMatrixKokkos() {}
@@ -6054,6 +6319,14 @@ class DViewCMatrixKokkos {
     // Method that update device view
     void update_device();
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
     // Deconstructor
     KOKKOS_INLINE_FUNCTION
     ~DViewCMatrixKokkos ();
@@ -6382,6 +6655,21 @@ void DViewCMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::update_device() {
     deep_copy(this_matrix_, this_matrix_host_);
 }
 
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DViewCMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return this_matrix_.label();
+}
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DViewCMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        this_matrix_host_(i) = val;
+    });
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 DViewCMatrixKokkos<T,Layout,ExecSpace,MemoryTraits>::~DViewCMatrixKokkos() {}
@@ -6454,12 +6742,24 @@ class RaggedRightArrayKokkos {
     //setup start indices
     void data_setup(const std::string& tag_string);
     
+    //return pointer
     KOKKOS_INLINE_FUNCTION
     T* pointer();
 
     //return the view
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view();
+    
+    //print values
+    void print() const;
+    
+    //set values to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
 
     // Kokkos views of strides and start indices
     Strides1D mystrides_;
@@ -6780,6 +7080,22 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> RaggedRightArrayKokkos<T,Layou
     return array_;
 }
 
+//set values to input
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
+KOKKOS_INLINE_FUNCTION
+void RaggedRightArrayKokkos<T,Layout,ExecSpace,MemoryTraits,ILayout>::set_values(T val) {
+    Kokkos::parallel_for("SetValues_RaggedRightArrayKokkos", length_, KOKKOS_CLASS_LAMBDA(const int i) {
+        array_(i) = val;
+    });
+}
+
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
+KOKKOS_INLINE_FUNCTION
+const std::string RaggedRightArrayKokkos<T,Layout,ExecSpace,MemoryTraits,ILayout>::get_name() const{
+    return array_.label();
+}
+
 // Destructor
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
 KOKKOS_INLINE_FUNCTION
@@ -6856,6 +7172,10 @@ class RaggedRightArrayofVectorsKokkos {
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view();
 
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
     // Kokkos views of strides and start indices
     Strides1D mystrides_;
     SArray1D start_index_;
@@ -6936,6 +7256,10 @@ class RaggedRightArrayofVectorsKokkos {
         }
     };
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
     // Destructor
     KOKKOS_INLINE_FUNCTION
     ~RaggedRightArrayofVectorsKokkos ( );
@@ -7126,6 +7450,22 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> RaggedRightArrayofVectorsKokko
     return array_;
 }
 
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
+KOKKOS_INLINE_FUNCTION
+void RaggedRightArrayofVectorsKokkos<T,Layout,ExecSpace,MemoryTraits, ILayout>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, length_), KOKKOS_CLASS_LAMBDA(const int i){
+        array_(i) = val;
+    });
+}
+
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
+KOKKOS_INLINE_FUNCTION
+const std::string RaggedRightArrayofVectorsKokkos<T,Layout,ExecSpace,MemoryTraits,ILayout>::get_name() const{
+    return array_.label();
+}
+
 // Destructor
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
 KOKKOS_INLINE_FUNCTION
@@ -7179,15 +7519,27 @@ class RaggedDownArrayKokkos {
     KOKKOS_INLINE_FUNCTION
     T& operator()(size_t i, size_t j) const;
     
+    //return pointer
     KOKKOS_INLINE_FUNCTION
     T* pointer();
 
     //return the view
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view();
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
     
     KOKKOS_INLINE_FUNCTION
     RaggedDownArrayKokkos& operator= (const RaggedDownArrayKokkos &temp);
+    
+    //print values
+    void print() const;
+    
+    //set values to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
 
     // Kokkos views of strides and start indices
     Strides1D mystrides_;
@@ -7243,6 +7595,10 @@ class RaggedDownArrayKokkos {
         }
     };
 
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
     // Destructor
     KOKKOS_INLINE_FUNCTION
     ~RaggedDownArrayKokkos ( );
@@ -7473,6 +7829,22 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> RaggedDownArrayKokkos<T,Layout
     return array_;
 }
 
+//set values to input
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
+KOKKOS_INLINE_FUNCTION
+void RaggedDownArrayKokkos<T,Layout,ExecSpace,MemoryTraits,ILayout>::set_values(T val) {
+    Kokkos::parallel_for("SetValues_RaggedDownArrayKokkos", length_, KOKKOS_CLASS_LAMBDA(const int i) {
+        array_(i) = val;
+    });
+}
+
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
+KOKKOS_INLINE_FUNCTION
+const std::string RaggedDownArrayKokkos<T,Layout,ExecSpace,MemoryTraits,ILayout>::get_name() const{
+    return array_.label();
+}
+
 // Destructor
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits, typename ILayout>
 KOKKOS_INLINE_FUNCTION
@@ -7518,6 +7890,14 @@ class DynamicRaggedRightArrayKokkos {
     //return the view
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view();
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+    
+    // set values to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
     
     // Overload operator() to access data as array(i,j),
     // where i=[0:N-1], j=[stride(i)]
@@ -7545,6 +7925,14 @@ class DynamicRaggedRightArrayKokkos {
       }
     };
     
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // set values to only previously non-empty indices based upon stride value
+    KOKKOS_INLINE_FUNCTION
+    void set_values_sparse(T val);
+
     // Destructor
     KOKKOS_INLINE_FUNCTION
     ~DynamicRaggedRightArrayKokkos ();
@@ -7648,6 +8036,32 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> DynamicRaggedRightArrayKokkos<
     return array_;
 }
 
+//set values to input
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DynamicRaggedRightArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos::parallel_for("SetValues_DynamicRaggedRightArrayKokkos", length_, KOKKOS_CLASS_LAMBDA(const int i) {
+        array_(i) = val;
+    });
+}
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DynamicRaggedRightArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values_sparse(T val) {
+    Kokkos::parallel_for( Kokkos::TeamPolicy<>( dim1_, Kokkos::AUTO, 32 ), KOKKOS_CLASS_LAMBDA ( const Kokkos::TeamPolicy<>::member_type &teamMember ) {
+        const int i_i = teamMember.league_rank();
+        Kokkos::parallel_for( Kokkos::TeamThreadRange( teamMember, 0, stride_(i_i) ), [&] ( const int (j_j) ) {
+            array_(dim2_*i_i+j_j) = val;    
+        });
+    });
+}
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DynamicRaggedRightArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return array_.label();
+}
+
 // Destructor
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
@@ -7696,6 +8110,14 @@ class DynamicRaggedDownArrayKokkos {
     //return the view
     KOKKOS_INLINE_FUNCTION
     TArray1D get_kokkos_view();
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+    
+    //set values to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
     
     // Overload operator() to access data as array(i,j),
     // where i=[stride(j)], j=[0:N-1]
@@ -7721,6 +8143,14 @@ class DynamicRaggedDownArrayKokkos {
         functor_strides_(index) = init_stride_;
       }
     };
+
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // set values to only previously non-empty indices based upon stride value
+    KOKKOS_INLINE_FUNCTION
+    void set_values_sparse(T val);
     
     // Destructor
     KOKKOS_INLINE_FUNCTION
@@ -7826,6 +8256,32 @@ Kokkos::View<T*, Layout, ExecSpace, MemoryTraits> DynamicRaggedDownArrayKokkos<T
     return array_;
 }
 
+//set values to input
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DynamicRaggedDownArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos::parallel_for("SetValues_DynamicRaggedDownArrayKokkos", length_, KOKKOS_CLASS_LAMBDA(const int i) {
+        array_(i) = val;
+    });
+}
+
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void DynamicRaggedDownArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values_sparse(T val) {
+    Kokkos::parallel_for( Kokkos::TeamPolicy<>( dim2_, Kokkos::AUTO, 32 ), KOKKOS_CLASS_LAMBDA ( const Kokkos::TeamPolicy<>::member_type &teamMember ) {
+        const int j_j = teamMember.league_rank();
+        Kokkos::parallel_for( Kokkos::TeamThreadRange( teamMember, 0, stride_(j_j) ), [&] ( const int (i_i) ) {
+            array_(dim1_*j_j+i_i) = val;    
+        });
+    });
+}
+// Get the name of the view
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string DynamicRaggedDownArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_name() const{
+    return array_.label();
+}
+
 // Destructor
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
@@ -7857,7 +8313,7 @@ class CSRArrayKokkos {
     CSRArrayKokkos();
     //CSRArray(CArray<T> data, CArray<T> col_ptrs, CArray<T> row_ptrs, size_t rows, size_t cols);
 
-   CSRArrayKokkos(
+    CSRArrayKokkos(
                CArrayKokkos<T, Layout, ExecSpace, MemoryTraits> &array,
                CArrayKokkos<size_t, Layout, ExecSpace, MemoryTraits> &start_index,
                CArrayKokkos<size_t, Layout, ExecSpace, MemoryTraits> &colum_index,
@@ -8001,6 +8457,10 @@ class CSRArrayKokkos {
     // int toCSC(CArray<T> &data, CArray<size_t> &col_ptrs, CArray<size_t> &row_ptrs);
 
     void to_dense(CArrayKokkos<T,Layout, ExecSpace, MemoryTraits>& A);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
     
     class init_start_indices_functor{
        public:
@@ -8012,6 +8472,11 @@ class CSRArrayKokkos {
                       mystart_index_(index) = 0;
              }
     };
+
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
     //destructor
     KOKKOS_INLINE_FUNCTION
     ~CSRArrayKokkos();
@@ -8240,6 +8705,13 @@ T& CSRArrayKokkos<T,Layout,ExecSpace, MemoryTraits>::get_val_flat(size_t k) cons
    return array_.data()[k];
 }
 
+// Get the name of the view
+template<typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string CSRArrayKokkos<T,Layout,ExecSpace, MemoryTraits>::get_name() const{
+    return array_.label();
+}
+
 template<typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 size_t CSRArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::get_col_flat(size_t k) const{
@@ -8261,6 +8733,8 @@ int CSRArrayKokkos<T,Layout, ExecSpace, MemoryTraits>::flat_index(size_t i, size
     return  -1;
 }
 
+
+
 //template<typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 //void CSRArrrayKokkos<T,Layout,ExecSpace, MemoryTraits>::from_dense(CArrayKokkos<T, Layout, ExecSpace, MemoryTraits> &starts,
 //                    CArrayKokkos<T, Layout, ExecSpace, MemoryTraits> &columns,
@@ -8309,6 +8783,14 @@ int CSRArray<T>::toCSC(CArray<T> &data, CArray<size_t> &col_ptrs, CArray<size_t>
 }
 */
 
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void CSRArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, nnz_), KOKKOS_CLASS_LAMBDA(const int i){
+        array_(i) = val;
+    });
+}
+
 template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 CSRArrayKokkos<T, Layout, ExecSpace, MemoryTraits>::~CSRArrayKokkos() {}
 
@@ -8329,159 +8811,168 @@ class CSCArrayKokkos
     
   public:
 
-      /**
-       * @brief Construct a new empty Sparse Col Array object
-       *
-       */
-      CSCArrayKokkos();
-
-      /**
-      * @brief Construct a new Sparse Col Array object
-      *
-      * @param array: 1d array of data values in order as read top to bottom, left to right
-      * @param row_index: 1d array that marks what row each element is in
-      * @param start_index: 1d array that marks where the first element of each column starts
-      * @param dim1: number of rows the matrix should have
-      * @param dim2: number of columns the matrix should have
-      */
-     CSCArrayKokkos(
-               CArrayKokkos<T, Layout, ExecSpace, MemoryTraits> &array,
-               CArrayKokkos<size_t, Layout, ExecSpace, MemoryTraits> &start_index,
-               CArrayKokkos<size_t, Layout, ExecSpace, MemoryTraits> &row_index,
-               size_t dim1, size_t dim2, const std::string & tag_string = DEFAULTSTRINGARRAY);
+    /**
+    * @brief Construct a new empty Sparse Col Array object
+    *
+    */
+    CSCArrayKokkos();
 
+    /**
+    * @brief Construct a new Sparse Col Array object
+    *
+    * @param array: 1d array of data values in order as read top to bottom, left to right
+    * @param row_index: 1d array that marks what row each element is in
+    * @param start_index: 1d array that marks where the first element of each column starts
+    * @param dim1: number of rows the matrix should have
+    * @param dim2: number of columns the matrix should have
+    */
+    CSCArrayKokkos(
+       CArrayKokkos<T, Layout, ExecSpace, MemoryTraits> &array,
+       CArrayKokkos<size_t, Layout, ExecSpace, MemoryTraits> &start_index,
+       CArrayKokkos<size_t, Layout, ExecSpace, MemoryTraits> &row_index,
+       size_t dim1, size_t dim2, const std::string & tag_string = DEFAULTSTRINGARRAY);
 
-      /**
-       * @brief Access A(i,j). Returns a dummy address with value 0 if A(i,j) is not allocated
-       *
-       * @param i : row
-       * @param j : column
-       * @return T& : address of array_ that corresponds to A(i,j)
-       */
-      KOKKOS_INLINE_FUNCTION
-      T &operator()(size_t i, size_t j) const;
-
-      /**
-       * @brief Overloaded copy operator
-       *
-       * @param temp : Array to copy
-       * @return CSCArray&
-       */
-      KOKKOS_INLINE_FUNCTION
-      CSCArrayKokkos &operator=(const CSCArrayKokkos &temp);
-
-      /**
-       * @brief  returns pointer to array_
-       *
-       */
-      KOKKOS_INLINE_FUNCTION
-      T *pointer() const;
-
-      /**
-       * @brief Same functionality as nnz(i) included for compatibility with the rest of matar
-       *
-       * @param i : row
-       * @return size_t
-       */
-      KOKKOS_INLINE_FUNCTION
-      size_t stride(size_t i) const;
-      
-      /**
-       * @brief Same functionality as operator() included for compatibility with the rest of matar
-       *
-       * @param i: row
-       * @param j: column
-       * @return T&
-       */
-      KOKKOS_INLINE_FUNCTION
-      T &value(size_t i, size_t j) const;
-
-      /**
-       * @brief Get the start_index array
-       *
-       * @return size_t* : returns start_index_
-       */
-      KOKKOS_INLINE_FUNCTION
-      size_t *get_starts() const;
-
-      /**
-       * @brief Get number of rows
-       *
-       * @return size_t  number of rows
-       */
-      KOKKOS_INLINE_FUNCTION
-      size_t dim1() const;
-      
-      /**
-       * @brief Get number of columns
-       *
-       * @return size_t number of columns
-       */
-      KOKKOS_INLINE_FUNCTION
-      size_t dim2() const;
-
-      /**
-       * @brief iterator notation for iterating through the non zeros values of row i.
-       *
-       * @param i : row
-       * @return T*
-       */
-      KOKKOS_INLINE_FUNCTION
-      T *begin(size_t i);
- 
-       /**
-       * @brief iterator notation for iterating through the non zeros values of row i.
-       *
-       * @param i : row
-       * @return T*
-       */
-      KOKKOS_INLINE_FUNCTION
-      T *end(size_t i);
-
-      // iterator for the raw data at row i
-      // i.e. return the index each element is the index in the 1 array
-      // This as the use of providing a reasonable way to get the column
-      // index and data value in the case you need both
-      KOKKOS_INLINE_FUNCTION
-      size_t begin_index(size_t i);
-
-      KOKKOS_INLINE_FUNCTION
-      size_t end_index(size_t i);
-
-      /**
-       * @brief Get the number of non zero elements in row i
-       *
-       * @param i : row to get
-       * @return size_t  : size of row
-       */
-      KOKKOS_INLINE_FUNCTION
-      size_t nnz(size_t i);
-      
-      /**
-       * @brief Get number of non zero elements total in array
-       *
-       * @return size_t
-       */
-      KOKKOS_INLINE_FUNCTION
-      size_t nnz() const;
-
-      // Use the index into the 1d array to get what value is stored there and what is the corresponding row
-      KOKKOS_INLINE_FUNCTION
-      T &get_val_flat(size_t k);
-
-      KOKKOS_INLINE_FUNCTION
-      size_t get_row_flat(size_t k);
-      
-      // reverse map function from A(i,j) to what element of data/col_pt_ it corersponds to
-      KOKKOS_INLINE_FUNCTION
-      int flat_index(size_t i, size_t j);
-      
-      // Convertor
-      //int toCSR(CArray<T> &data, CArray<size_t> &row_ptrs, CArray<size_t> &col_ptrs);
-      //void to_dense(FArray<T> &A);
-      // destructor
-      KOKKOS_INLINE_FUNCTION
-      ~CSCArrayKokkos();
+
+    /**
+    * @brief Access A(i,j). Returns a dummy address with value 0 if A(i,j) is not allocated
+    *
+    * @param i : row
+    * @param j : column
+    * @return T& : address of array_ that corresponds to A(i,j)
+    */
+    KOKKOS_INLINE_FUNCTION
+    T &operator()(size_t i, size_t j) const;
+
+    /**
+    * @brief Overloaded copy operator
+    *
+    * @param temp : Array to copy
+    * @return CSCArray&
+    */
+    KOKKOS_INLINE_FUNCTION
+    CSCArrayKokkos &operator=(const CSCArrayKokkos &temp);
+
+    /**
+    * @brief  returns pointer to array_
+    *
+    */
+    KOKKOS_INLINE_FUNCTION
+    T *pointer() const;
+
+    /**
+    * @brief Same functionality as nnz(i) included for compatibility with the rest of matar
+    *
+    * @param i : row
+    * @return size_t
+    */
+    KOKKOS_INLINE_FUNCTION
+    size_t stride(size_t i) const;
+
+    /**
+    * @brief Same functionality as operator() included for compatibility with the rest of matar
+    *
+    * @param i: row
+    * @param j: column
+    * @return T&
+    */
+    KOKKOS_INLINE_FUNCTION
+    T &value(size_t i, size_t j) const;
+
+    /**
+    * @brief Get the start_index array
+    *
+    * @return size_t* : returns start_index_
+    */
+    KOKKOS_INLINE_FUNCTION
+    size_t *get_starts() const;
+
+    /**
+    * @brief Get number of rows
+    *
+    * @return size_t  number of rows
+    */
+    KOKKOS_INLINE_FUNCTION
+    size_t dim1() const;
+
+    /**
+    * @brief Get number of columns
+    *
+    * @return size_t number of columns
+    */
+    KOKKOS_INLINE_FUNCTION
+    size_t dim2() const;
+
+    /**
+    * @brief iterator notation for iterating through the non zeros values of row i.
+    *
+    * @param i : row
+    * @return T*
+    */
+    KOKKOS_INLINE_FUNCTION
+    T *begin(size_t i);
+
+    /**
+    * @brief iterator notation for iterating through the non zeros values of row i.
+    *
+    * @param i : row
+    * @return T*
+    */
+    KOKKOS_INLINE_FUNCTION
+    T *end(size_t i);
+
+    // iterator for the raw data at row i
+    // i.e. return the index each element is the index in the 1 array
+    // This as the use of providing a reasonable way to get the column
+    // index and data value in the case you need both
+    KOKKOS_INLINE_FUNCTION
+    size_t begin_index(size_t i);
+
+    KOKKOS_INLINE_FUNCTION
+    size_t end_index(size_t i);
+
+    /**
+    * @brief Get the number of non zero elements in row i
+    *
+    * @param i : row to get
+    * @return size_t  : size of row
+    */
+    KOKKOS_INLINE_FUNCTION
+    size_t nnz(size_t i);
+
+    /**
+    * @brief Get number of non zero elements total in array
+    *
+    * @return size_t
+    */
+    KOKKOS_INLINE_FUNCTION
+    size_t nnz() const;
+
+    // Use the index into the 1d array to get what value is stored there and what is the corresponding row
+    KOKKOS_INLINE_FUNCTION
+    T &get_val_flat(size_t k);
+
+    KOKKOS_INLINE_FUNCTION
+    size_t get_row_flat(size_t k);
+
+    // reverse map function from A(i,j) to what element of data/col_pt_ it corersponds to
+    KOKKOS_INLINE_FUNCTION
+    int flat_index(size_t i, size_t j);
+
+    // Get the name of the view
+    KOKKOS_INLINE_FUNCTION
+    const std::string get_name() const;
+
+    // Convertor
+    //int toCSR(CArray<T> &data, CArray<size_t> &row_ptrs, CArray<size_t> &col_ptrs);
+    //void to_dense(FArray<T> &A);
+
+    // set values on host to input
+    KOKKOS_INLINE_FUNCTION
+    void set_values(T val);
+
+    // destructor
+    KOKKOS_INLINE_FUNCTION
+    ~CSCArrayKokkos();
 };
 
 template<typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
@@ -8634,6 +9125,13 @@ T& CSCArrayKokkos<T,Layout, ExecSpace, MemoryTraits>::get_val_flat(size_t k){
     return array_.data()[k];
 }
 
+template<typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+const std::string CSCArrayKokkos<T,Layout, ExecSpace, MemoryTraits>::get_name() const{
+    return array_.label();
+}
+
+
 template<typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
 KOKKOS_INLINE_FUNCTION
 size_t CSCArrayKokkos<T,Layout, ExecSpace, MemoryTraits>::get_row_flat(size_t k){
@@ -8655,6 +9153,14 @@ int CSCArrayKokkos<T,Layout, ExecSpace, MemoryTraits>::flat_index(size_t i, size
     return  -1;
 }
 
+template <typename T, typename Layout, typename ExecSpace, typename MemoryTraits>
+KOKKOS_INLINE_FUNCTION
+void CSCArrayKokkos<T,Layout,ExecSpace,MemoryTraits>::set_values(T val) {
+    Kokkos:parallel_for( Kokkos::RangePolicy<> ( 0, nnz_), KOKKOS_CLASS_LAMBDA(const int i){
+        array_(i) = val;
+    });
+}
+
 // Assumes that data, col_ptrs, and row_ptrs
 // have been allocated size already before this call
 // Returns the data in this csr format but as represented as the appropriatte vectors
diff --git a/test/test_cases/CMakeLists.txt b/test/test_cases/CMakeLists.txt
index 74feb6b4..6174042d 100644
--- a/test/test_cases/CMakeLists.txt
+++ b/test/test_cases/CMakeLists.txt
@@ -18,6 +18,9 @@ target_link_libraries(${This}
 add_executable(test_CArrayKokkos test_CArrayKokkos.cpp)
 target_link_libraries(test_CArrayKokkos matar gtest_main)
 
+add_executable(test_DCArrayKokkos test_DCArrayKokkos.cpp)
+target_link_libraries(test_DCArrayKokkos matar gtest_main)
+
 
 if (KOKKOKS)
     target_link_libraries(${This} Kokkos::kokkos)
diff --git a/test/test_cases/test_CArrayKokkos.cpp b/test/test_cases/test_CArrayKokkos.cpp
index 845c8465..9f9e88bb 100644
--- a/test/test_cases/test_CArrayKokkos.cpp
+++ b/test/test_cases/test_CArrayKokkos.cpp
@@ -25,7 +25,7 @@ CArrayKokkos<double> return_CArrayKokkos(int dims, std::vector<int> sizes)
         A = CArrayKokkos<double>(sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], "A_5D_CArrayKokkos");
     }
     else if(dims == 6){
-        A = CArrayKokkos<double>(sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], sizes[5], "A_7D_CArrayKokkos");
+        A = CArrayKokkos<double>(sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], sizes[5], "A_6D_CArrayKokkos");
     }
     else if(dims == 7){
         A = CArrayKokkos<double>(sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], sizes[5], sizes[6], "A_7D_CArrayKokkos");
@@ -108,7 +108,7 @@ TEST(Test_CArrayKokkos, order)
 }
 
 
-// Test order function
+// Test pointer function
 TEST(Test_CArrayKokkos, pointer)
 {
     std::vector<int> sizes;
@@ -123,6 +123,29 @@ TEST(Test_CArrayKokkos, pointer)
     }
 }
 
+// Test get name function
+TEST(Test_CArrayKokkos, names)
+{
+    std::vector<int> sizes;
+    std::vector <std::string> names = {
+        "A_1D_CArrayKokkos",
+        "A_2D_CArrayKokkos",
+        "A_3D_CArrayKokkos",
+        "A_4D_CArrayKokkos",
+        "A_5D_CArrayKokkos",
+        "A_6D_CArrayKokkos",
+        "A_7D_CArrayKokkos"
+    };
+
+    for(int i = 0; i < 7; i++){
+
+        int dims = i+1;
+        sizes.push_back(dims*2);
+        CArrayKokkos<double> A = return_CArrayKokkos(dims, sizes);
+        EXPECT_EQ(names[i], A.get_name());
+    }
+}
+
 // Add test for late initialization
 TEST(Test_CArrayKokkos, late_init)
 {
diff --git a/test/test_cases/test_DCArrayKokkos.cpp b/test/test_cases/test_DCArrayKokkos.cpp
new file mode 100644
index 00000000..d919194b
--- /dev/null
+++ b/test/test_cases/test_DCArrayKokkos.cpp
@@ -0,0 +1,192 @@
+#include "matar.h"
+#include "gtest/gtest.h"
+#include <stdio.h>
+
+using namespace mtr; // matar namespace
+
+DCArrayKokkos<double> return_DCArrayKokkos(int dims, std::vector<int> sizes)
+{
+
+    DCArrayKokkos<double> A;
+
+    if(dims == 1){
+        A = DCArrayKokkos<double>(sizes[0], "A_1D_DCArrayKokkos");
+    }
+    else if(dims == 2){
+        A = DCArrayKokkos<double>(sizes[0], sizes[1], "A_2D_DCArrayKokkos");
+    }
+    else if(dims == 3){
+        A = DCArrayKokkos<double>(sizes[0], sizes[1], sizes[2], "A_3D_DCArrayKokkos");
+    }
+    else if(dims == 4){
+        A = DCArrayKokkos<double>(sizes[0], sizes[1], sizes[2], sizes[3], "A_4D_DCArrayKokkos");
+    }
+    else if(dims == 5){
+        A = DCArrayKokkos<double>(sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], "A_5D_DCArrayKokkos");
+    }
+    else if(dims == 6){
+        A = DCArrayKokkos<double>(sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], sizes[5], "A_6D_DCArrayKokkos");
+    }
+    else if(dims == 7){
+        A = DCArrayKokkos<double>(sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], sizes[5], sizes[6], "A_7D_DCArrayKokkos");
+    }
+    else{
+        std::cout<<"Dims must be between 1 and 7 for DCArrayKokkos" << std::endl;
+    }
+    return A;
+}
+
+
+// Test size function
+TEST(Test_DCArrayKokkos, size)
+{
+    std::vector<int> sizes;  // Size of each dimension
+    int val = 1;  // Expected total length of data
+
+    for(int i = 0; i < 7; i++){
+
+        int dims = i+1;
+
+        sizes.push_back(dims*2);
+
+        DCArrayKokkos<double> A = return_DCArrayKokkos(dims, sizes);
+        val*= dims*2;
+
+        EXPECT_EQ(val, A.size());
+    }
+}
+
+
+// Test extent function
+TEST(Test_DCArrayKokkos, extent)
+{
+    std::vector<int> sizes; // Size of each dimension
+    int val = 1; // Expected total length of data
+
+    for(int i = 0; i < 7; i++){
+
+        int dims = i+1;
+
+        sizes.push_back(dims*2);
+
+        DCArrayKokkos<double> A = return_DCArrayKokkos(dims, sizes);
+        val*= dims*2;
+
+        EXPECT_EQ(val, A.extent());
+    }
+}
+
+// Test dims function
+TEST(Test_DCArrayKokkos, dims)
+{
+
+    // Note: extend to other dims when initialized to zero
+
+    std::vector<int> sizes;
+    for(int i = 0; i < 7; i++){
+
+        int dims = i+1;
+
+        sizes.push_back(dims*2);
+
+        DCArrayKokkos<double> A = return_DCArrayKokkos(dims, sizes);
+
+        EXPECT_EQ(sizes[i], A.dims(i));
+    }
+}
+
+// Test order function
+TEST(Test_DCArrayKokkos, order)
+{
+    std::vector<int> sizes;
+    for(int i = 0; i < 7; i++){
+
+        int dims = i+1;
+        sizes.push_back(dims*2);
+        DCArrayKokkos<double> A = return_DCArrayKokkos(dims, sizes);
+        EXPECT_EQ(dims, A.order());
+    }
+}
+
+
+// Test get name function
+TEST(Test_DCArrayKokkos, names)
+{
+    std::vector<int> sizes;
+    std::vector <std::string> names = {
+        "A_1D_DCArrayKokkos",
+        "A_2D_DCArrayKokkos",
+        "A_3D_DCArrayKokkos",
+        "A_4D_DCArrayKokkos",
+        "A_5D_DCArrayKokkos",
+        "A_6D_DCArrayKokkos",
+        "A_7D_DCArrayKokkos"
+    };
+
+    for(int i = 0; i < 7; i++){
+
+        int dims = i+1;
+        sizes.push_back(dims*2);
+        DCArrayKokkos<double> A = return_DCArrayKokkos(dims, sizes);
+        EXPECT_EQ(names[i], A.get_name());
+    }
+}
+
+// Add test for late initialization
+TEST(Test_DCArrayKokkos, late_init)
+{
+    std::vector<int> sizes;  // Size of each dimension
+    int val = 1;  // Expected total length of data
+
+    DCArrayKokkos<double> A;
+
+    for(int i = 0; i < 7; i++){
+
+        int dims = i+1;
+
+        sizes.push_back(dims*2);
+
+        A = return_DCArrayKokkos(dims, sizes);
+        val*= dims*2;
+
+        EXPECT_EQ(val, A.size());
+    }
+}
+
+
+// Add test for operator = overload
+TEST(Test_DCArrayKokkos, eq_overload)
+{
+    const int size = 100;
+    DCArrayKokkos<double> A(size, size);
+
+    DCArrayKokkos<double> B(size, size);
+
+    for(int i = 0; i < size; i++){
+        for(int j = 0; j < size; j++){
+            A(i,j) = (double)i + (double)j;
+        }
+    }
+
+    B = A;
+
+    for(int i = 0; i < size; i++){
+        for(int j = 0; j < size; j++){
+
+            EXPECT_EQ(B(i,j), (double)i + (double)j);
+        }
+    }
+}
+
+
+int main(int argc, char* argv[])
+{
+    Kokkos::initialize(argc, argv);
+    {  
+        int result = 0;
+        testing::InitGoogleTest(&argc, argv);
+        result = RUN_ALL_TESTS();
+        return result;
+    }
+    Kokkos::finalize();
+}
\ No newline at end of file