add DataFrame asMatrix() method to convert to a matrix

Author: bhaller

EidosScribe/EidosHelpClasses.rtf

@@ -193,7 +193,27 @@
 \f1\fs22  methods\
 \pard\pardeftab397\li720\fi-446\ri720\sb180\sa60\partightenfactor0
 
-\f3\i0\fs18 \cf2 \'96\'a0(void)cbind(object\'a0source, ...)\
+\f3\i0\fs18 \cf2 \'96\'a0(*)asMatrix(void)\
+\pard\pardeftab397\li547\ri720\sb60\sa60\partightenfactor0
+
+\f4\fs20 \cf2 Returns a matrix representation of the 
+\f3\fs18 DataFrame
+\f4\fs20 .  The matrix will have the same type as the elements of the 
+\f3\fs18 DataFrame
+\f4\fs20 ; if the 
+\f3\fs18 DataFrame
+\f4\fs20  contains more than one type of element, an error will be raised.  The order of the columns of the 
+\f3\fs18 DataFrame
+\f4\fs20  will be preserved.  This method is useful, for example, if you wish to read in a text file as a matrix; you can use 
+\f3\fs18 readCSV()
+\f4\fs20  to read the file as a 
+\f3\fs18 DataFrame
+\f4\fs20 , and then convert it to a matrix with 
+\f3\fs18 asMatrix()
+\f4\fs20 .\
+\pard\pardeftab397\li720\fi-446\ri720\sb180\sa60\partightenfactor0
+
+\f3\fs18 \cf2 \'96\'a0(void)cbind(object\'a0source, ...)\
 \pard\pardeftab397\li547\ri720\sb60\sa60\partightenfactor0
 
 \f4\fs20 \cf2 Adds all of the columns contained by 

QtSLiM/help/EidosHelpClasses.html

@@ -43,6 +43,8 @@
 <p class="p3">nrow =&gt; (integer$)</p>
 <p class="p4">The number of rows in the <span class="s1">DataFrame</span> (i.e., the number of elements in a column).<span class="Apple-converted-space">  </span>This will be the same for every column, by definition.</p>
 <p class="p2"><i>5.2.2<span class="Apple-converted-space">  </span></i><span class="s1"><i>DataFrame</i></span><i> methods</i></p>
+<p class="p3">– (*)asMatrix(void)</p>
+<p class="p4">Returns a matrix representation of the <span class="s1">DataFrame</span>.<span class="Apple-converted-space">  </span>The matrix will have the same type as the elements of the <span class="s1">DataFrame</span>; if the <span class="s1">DataFrame</span> contains more than one type of element, an error will be raised.<span class="Apple-converted-space">  </span>The order of the columns of the <span class="s1">DataFrame</span> will be preserved.<span class="Apple-converted-space">  </span>This method is useful, for example, if you wish to read in a text file as a matrix; you can use <span class="s1">readCSV()</span> to read the file as a <span class="s1">DataFrame</span>, and then convert it to a matrix with <span class="s1">asMatrix()</span>.</p>
 <p class="p3">– (void)cbind(object source, ...)</p>
 <p class="p4">Adds all of the columns contained by <span class="s1">source</span> (which must be a <span class="s1">Dictionary</span> or a subclass of <span class="s1">Dictionary</span> such as <span class="s1">DataFrame</span>) to the receiver.<span class="Apple-converted-space">  </span>This method makes the target <span class="s1">DataFrame</span> wider, by adding new columns.<span class="Apple-converted-space">  </span>If <span class="s1">source</span> contains a column name that is already defined in the target, an error will result.<span class="Apple-converted-space">  </span>As always for <span class="s1">DataFrame</span>, the columns of the resulting <span class="s1">DataFrame</span> must all be the same length.</p>
 <p class="p4">The <span class="s1">source</span> parameter may be a non-singleton vector containing multiple <span class="s1">Dictionary</span> objects, and additional <span class="s1">Dictionary</span> vectors may be supplied (thus the ellipsis in the signature).<span class="Apple-converted-space">  </span>Each <span class="s1">Dictionary</span> supplied will be added to the target, in the order supplied.</p>

VERSIONS

@@ -18,6 +18,7 @@ development head (in the master branch):
 	improve memory usage for Individual, down to 192 bytes from 232 bytes, by compactifying the color information for SLiMgui and rearranging ivars to minimize wasted space
 	the color property on Individual no longer guarantees that the value read equals the value set; when a color is set, it is now converted to RGB, so named colors do not round-trip
 	add a meanParentAge property, to make calculating generation length simpler; unavailable in WF models (like age), 0 for parentless individuals
+	add DataFrame asMatrix() method to convert a DataFrame into a matrix, if all columns are the same type/class
 
 
 version 4.0 (Eidos version 3.0):

eidos/eidos_class_DataFrame.cpp

@@ -357,6 +357,7 @@ EidosValue_SP EidosDataFrame::ExecuteInstanceMethod(EidosGlobalStringID p_method
 
 	switch (p_method_id)
 	{
+		case gEidosID_asMatrix:					return ExecuteMethod_asMatrix(p_method_id, p_arguments, p_interpreter);
 		case gEidosID_cbind:					return ExecuteMethod_cbind(p_method_id, p_arguments, p_interpreter);
 		case gEidosID_rbind:					return ExecuteMethod_rbind(p_method_id, p_arguments, p_interpreter);
 		case gEidosID_subset:					return ExecuteMethod_subset(p_method_id, p_arguments, p_interpreter);
@@ -366,6 +367,76 @@ EidosValue_SP EidosDataFrame::ExecuteInstanceMethod(EidosGlobalStringID p_method
 	}
 }
 
+//	*********************	- (void)asMatrix()
+//
+EidosValue_SP EidosDataFrame::ExecuteMethod_asMatrix(EidosGlobalStringID p_method_id, const std::vector<EidosValue_SP> &p_arguments, EidosInterpreter &p_interpreter)
+{
+#pragma unused (p_method_id, p_interpreter)
+	// First determine what type the matrix would be, and check that all columns match that type
+	int64_t nrow = RowCount();
+	const EidosDictionaryHashTable *symbols = DictionarySymbols();
+	int64_t ncol = symbols->size();
+	EidosValue_SP type_template;
+	const EidosClass *class_template = nullptr;
+	
+	if (ncol == 0)
+	{
+		type_template = gStaticEidosValue_Logical_ZeroVec;		// with no columns, we have no way to know the type, so we go with "logical", following R
+	}
+	else
+	{
+		for (auto symbols_iter : *symbols)
+		{
+			if (!type_template)
+			{
+				type_template = symbols_iter.second;
+				if (type_template->Type() == EidosValueType::kValueObject)
+					class_template = ((EidosValue_Object *)(type_template.get()))->Class();
+			}
+			else if (type_template->Type() != symbols_iter.second->Type())
+			{
+				EIDOS_TERMINATION << "ERROR (EidosDataFrame::ExecuteMethod_asMatrix): asMatrix() requires that every column of the target DataFrame is the same type (" << type_template->Type() << " != " << symbols_iter.second->Type() << ")." << EidosTerminate(nullptr);
+			}
+			else if (class_template)
+			{
+				const EidosClass *class_column = ((EidosValue_Object *)(symbols_iter.second.get()))->Class();
+				
+				if (class_template != class_column)
+					EIDOS_TERMINATION << "ERROR (EidosDataFrame::ExecuteMethod_asMatrix): asMatrix() requires that every object element in the target DataFrame is the same class (" << class_template->ClassName() << " != " << class_column->ClassName() << ")." << EidosTerminate(nullptr);
+			}
+		}
+	}
+	
+	// Create the matrix; for now we use a slow implementation that is type-agnostic and does not resize to fit first, probably this is unlikely to be a bottleneck
+	//int64_t data_count = nrow * ncol;
+	EidosValue_SP result_SP = type_template->NewMatchingType();
+	EidosValue *result = result_SP.get();
+	
+	//result_SP->resize_no_initialize(data_count);
+	
+	// Fill in all the values, in sorted column order
+	const std::vector<std::string> *keys = SortedKeys();
+	
+	for (const std::string &key : *keys)
+	{
+		auto key_iter = symbols->find(key);
+		
+		if (key_iter == symbols->end())
+			EIDOS_TERMINATION << "ERROR (EidosDataFrame::ExecuteMethod_asMatrix): (internal error) key not found." << EidosTerminate(nullptr);
+		
+		EidosValue *column_value = key_iter->second.get();
+		
+		for (int64_t i = 0; i < nrow; ++i)
+			result->PushValueFromIndexOfEidosValue((int)i, *column_value, nullptr);
+	}
+	
+	const int64_t dim_buf[2] = {nrow, ncol};
+	
+	result_SP->SetDimensions(2, dim_buf);
+	
+	return result_SP;
+}
+
 //	*********************	- (void)cbind(object source, ...)
 //
 EidosValue_SP EidosDataFrame::ExecuteMethod_cbind(EidosGlobalStringID p_method_id, const std::vector<EidosValue_SP> &p_arguments, EidosInterpreter &p_interpreter)
@@ -1124,6 +1195,7 @@ const std::vector<EidosMethodSignature_CSP> *EidosDataFrame_Class::Methods(void)
 	{
 		methods = new std::vector<EidosMethodSignature_CSP>(*super::Methods());
 
+		methods->emplace_back((EidosInstanceMethodSignature *)(new EidosInstanceMethodSignature(gEidosStr_asMatrix, kEidosValueMaskAny)));
 		methods->emplace_back((EidosInstanceMethodSignature *)(new EidosInstanceMethodSignature(gEidosStr_cbind, kEidosValueMaskVOID))->AddObject("source", nullptr)->AddEllipsis());
 		methods->emplace_back((EidosInstanceMethodSignature *)(new EidosInstanceMethodSignature(gEidosStr_rbind, kEidosValueMaskVOID))->AddObject("source", nullptr)->AddEllipsis());
 		methods->emplace_back((EidosInstanceMethodSignature *)(new EidosInstanceMethodSignature(gEidosStr_subset, kEidosValueMaskAny))

eidos/eidos_class_DataFrame.h

@@ -64,6 +64,7 @@ class EidosDataFrame : public EidosDictionaryRetained
 	virtual EidosValue_SP GetProperty(EidosGlobalStringID p_property_id) override;
 
 	virtual EidosValue_SP ExecuteInstanceMethod(EidosGlobalStringID p_method_id, const std::vector<EidosValue_SP> &p_arguments, EidosInterpreter &p_interpreter) override;
+	EidosValue_SP ExecuteMethod_asMatrix(EidosGlobalStringID p_method_id, const std::vector<EidosValue_SP> &p_arguments, EidosInterpreter &p_interpreter);
 	EidosValue_SP ExecuteMethod_cbind(EidosGlobalStringID p_method_id, const std::vector<EidosValue_SP> &p_arguments, EidosInterpreter &p_interpreter);
 	EidosValue_SP ExecuteMethod_rbind(EidosGlobalStringID p_method_id, const std::vector<EidosValue_SP> &p_arguments, EidosInterpreter &p_interpreter);
 	EidosValue_SP ExecuteMethod_subset(EidosGlobalStringID p_method_id, const std::vector<EidosValue_SP> &p_arguments, EidosInterpreter &p_interpreter);

eidos/eidos_globals.cpp

@@ -2732,6 +2732,7 @@ const std::string &gEidosStr_colNames = EidosRegisteredString("colNames", gEidos
 const std::string &gEidosStr_dim = EidosRegisteredString("dim", gEidosID_dim);
 const std::string &gEidosStr_ncol = EidosRegisteredString("ncol", gEidosID_ncol);
 const std::string &gEidosStr_nrow = EidosRegisteredString("nrow", gEidosID_nrow);
+const std::string &gEidosStr_asMatrix = EidosRegisteredString("asMatrix", gEidosID_asMatrix);
 const std::string &gEidosStr_cbind = EidosRegisteredString("cbind", gEidosID_cbind);
 const std::string &gEidosStr_rbind = EidosRegisteredString("rbind", gEidosID_rbind);
 const std::string &gEidosStr_subset = EidosRegisteredString("subset", gEidosID_subset);

eidos/eidos_globals.h

@@ -907,6 +907,7 @@ extern const std::string &gEidosStr_colNames;
 extern const std::string &gEidosStr_dim;
 extern const std::string &gEidosStr_ncol;
 extern const std::string &gEidosStr_nrow;
+extern const std::string &gEidosStr_asMatrix;
 extern const std::string &gEidosStr_cbind;
 extern const std::string &gEidosStr_rbind;
 extern const std::string &gEidosStr_subset;
@@ -1028,6 +1029,7 @@ enum _EidosGlobalStringID : uint32_t
 	gEidosID_dim,
 	gEidosID_ncol,
 	gEidosID_nrow,
+	gEidosID_asMatrix,
 	gEidosID_cbind,
 	gEidosID_rbind,
 	gEidosID_subset,

eidos/eidos_test_functions_other.cpp

@@ -1148,6 +1148,18 @@ void _RunClassTests(std::string temp_path)
 	EidosAssertScriptSuccess_L("x = DataFrame('b', 1:3, 'a', c(T,F,T)); identical(x.ncol, 2);", true);
 	EidosAssertScriptSuccess_L("x = DataFrame('b', 1:3, 'a', c(T,F,T)); identical(x.nrow, 3);", true);
 
+	// DataFrame asMatrix()
+	EidosAssertScriptRaise("x = DataFrame('a', 1:3, 'b', c(T,F,T)); x.asMatrix();", 42, "is the same type (logical != integer)");
+	EidosAssertScriptRaise("x = DataFrame('a', DataFrame(), 'b', Dictionary()); x.asMatrix();", 54, "is the same class (Dictionary != DataFrame)");
+	EidosAssertScriptSuccess_L("x = DataFrame('a', 1:5, 'b', 11:15); m1 = x.asMatrix(); m2 = matrix(c(1:5, 11:15), ncol=2, byrow=F); identical(m1, m2);", true);
+	EidosAssertScriptSuccess_L("x = DataFrame('b', 1:5, 'a', 11:15); m1 = x.asMatrix(); m2 = matrix(c(1:5, 11:15), ncol=2, byrow=F); identical(m1, m2);", true);
+	EidosAssertScriptSuccess_L("x = DataFrame('b', 11:15, 'a', 1:5); m1 = x.asMatrix(); m2 = matrix(c(11:15, 1:5), ncol=2, byrow=F); identical(m1, m2);", true);
+	EidosAssertScriptSuccess_L("x = DataFrame('a', 11:15, 'b', 1:5); m1 = x.asMatrix(); m2 = matrix(c(11:15, 1:5), ncol=2, byrow=F); identical(m1, m2);", true);
+	EidosAssertScriptSuccess_L("x = DataFrame('b', 11.0:15, 'a', 1.0:5); m1 = x.asMatrix(); m2 = matrix(c(11.0:15, 1.0:5), ncol=2, byrow=F); identical(m1, m2);", true);
+	EidosAssertScriptSuccess_L("x = DataFrame('b', c('foo','bar'), 'a', c('baz','barbaz')); m1 = x.asMatrix(); m2 = matrix(c('foo','bar','baz','barbaz'), ncol=2, byrow=F); identical(m1, m2);", true);
+	EidosAssertScriptSuccess_L("x = DataFrame('b', c(T,T,F), 'a', c(F,T,F)); m1 = x.asMatrix(); m2 = matrix(c(T,T,F,F,T,F), ncol=2, byrow=F); identical(m1, m2);", true);
+	EidosAssertScriptSuccess_L("d1 = Dictionary('foo', 1:8); d2 = Dictionary('baz', 11:18); x = DataFrame('b', d1, 'a', d2); m1 = x.asMatrix(); m2 = matrix(c(d1, d2), ncol=2, byrow=F); identical(m1, m2);", true);
+	
 	// DataFrame cbind()
 	EidosAssertScriptSuccess_L("x = DataFrame('b', 1:3, 'a', c(T,F,T)); y = DataFrame(); y.cbind(x); y.identicalContents(x);", true);
 	EidosAssertScriptSuccess_L("x = DataFrame('b', 1:3, 'a', c(T,F,T)); y = DataFrame('c', 2.0:4); y.cbind(x); DataFrame('c', 2.0:4, 'b', 1:3, 'a', c(T,F,T)).identicalContents(y);", true);