Push down rawMatrixEntry

Author: local-ring

M2/Macaulay2/e/interface/matrix.cpp

@@ -57,21 +57,7 @@ const RingElement /* or null */ *rawMatrixEntry(const Matrix *M,
 {
   try
     {
-      if (r < 0 || r >= M->n_rows())
-        {
-          ERROR("matrix row index %d out of range 0 .. %d", r, M->n_rows() - 1);
-          return nullptr;
-        }
-      if (c < 0 || c >= M->n_cols())
-        {
-          ERROR("matrix column index %d out of range 0 .. %d",
-                c,
-                M->n_cols() - 1);
-          return nullptr;
-        }
-      ring_elem result;
-      result = M->elem(r, c);
-      return RingElement::make_raw(M->get_ring(), result);
+      return M->entry(r, c);
   } catch (const exc::engine_error& e)
     {
       ERROR(e.what());

M2/Macaulay2/e/matrix.cpp

@@ -58,6 +58,23 @@ unsigned int Matrix::computeHashValue() const
   return hashval;
 }
 
+const RingElement /* or null */ *Matrix::entry(int r, int c) const
+{
+  if (r < 0 || r >= n_rows())
+    {
+      ERROR("matrix row index %d out of range 0 .. %d", r, n_rows() - 1);
+      return nullptr;
+    }
+  if (c < 0 || c >= n_cols())
+    {
+      ERROR("matrix column index %d out of range 0 .. %d",
+            c,
+            n_cols() - 1);
+      return nullptr;
+    }
+  return RingElement::make_raw(get_ring(), elem(r, c));
+}
+
 engine_RawRingElementArrayArrayOrNull Matrix::entries() const
 {
   int ncols = n_cols();

M2/Macaulay2/e/matrix.hpp

@@ -10,6 +10,7 @@
 #include <vector>
 
 class MatrixConstructor;
+class RingElement;
 
 /**
  * \ingroup matrices
@@ -92,6 +93,7 @@ class Matrix : public EngineObject
   ring_elem elem(int i, int j) const;
   vec &elem(int i) { return mEntries[i]; }
   const vec &elem(int i) const { return mEntries[i]; }
+  const RingElement /* or null */ *entry(int r, int c) const;
   engine_RawRingElementArrayArrayOrNull entries() const;
   /*****************************************/
 

M2/Macaulay2/e/unit-tests/MatrixIOTest.cpp

@@ -140,6 +140,35 @@ TEST(Matrix, entriesFromSparseColumns)
     }
 }
 
+TEST(Matrix, entry)
+{
+  const Ring* R = simplePolynomialRing(101, {"x"});
+  const FreeModule* target = R->make_FreeModule(3);
+  MatrixConstructor mat(target, 4);
+
+  mat.set_entry(1, 2, R->from_long(17));
+  mat.compute_column_degrees();
+
+  const Matrix* M = mat.to_matrix();
+  const RingElement* nonzero = M->entry(1, 2);
+  ASSERT_NE(nonzero, nullptr);
+  EXPECT_EQ(nonzero->get_ring(), R);
+  EXPECT_TRUE(R->is_equal(nonzero->get_value(), R->from_long(17)));
+
+  const RingElement* zero = M->entry(0, 0);
+  ASSERT_NE(zero, nullptr);
+  EXPECT_EQ(zero->get_ring(), R);
+  EXPECT_TRUE(R->is_zero(zero->get_value()));
+
+  EXPECT_EQ(M->entry(3, 0), nullptr);
+  EXPECT_TRUE(error());
+  EXPECT_STREQ(error_message(), "matrix row index 3 out of range 0 .. 2");
+
+  EXPECT_EQ(M->entry(0, 4), nullptr);
+  EXPECT_TRUE(error());
+  EXPECT_STREQ(error_message(), "matrix column index 4 out of range 0 .. 3");
+}
+
 TEST(Matrix, concatArray)
 {
   const PolynomialRing* R = simplePolynomialRing(101, {"x", "y"});