How to write nice and useful table functions (for developers)

/// <summary>
/// Add scalar value x to all key figures of input table
/// </summary>
/// <param name="tbl">Input table</param>
/// <param name="x">Scalar value</param>
/// <returns>Output table</returns>
public static MatrixTable AddScalarToAllKeyFigures(MatrixTable tbl, double x)

/// <summary>
/// Round all key figures of table
/// </summary>
/// <param name="tbl">Input table</param>
/// <param name="DigitCount">Number of digits after decimal point after rounding</param>
/// <returns>Output table with rounded key figures</returns>
public static MatrixTable Round(MatrixTable tbl, int DigitCount)
{
	try
	{
		return MatrixTable.TransformKeyFigures(tbl, x => Math.Round(x, DigitCount));
	}
	catch (Exception ex)
	{
		throw new Exception("MatrixTable.Round: \n" + ex.Message);
	}
}
 
/// <summary>
/// Round selected key figure of table
/// </summary>
/// <param name="tbl">Input table</param>
/// <param name="DigitCount">Number of digits after decimal point after rounding</param>
/// <param name="KeyFigure">Name of key figure to be rounded</param>
/// <returns>Output table with rounded key figures</returns>
public static MatrixTable Round(MatrixTable tbl, int DigitCount, string KeyFigure)
{
	try
	{
		return MatrixTable.TransformKeyFigures(tbl, x => Math.Round(x, DigitCount), KeyFigure, KeyFigure);
	}
	catch (Exception ex)
	{
		throw new Exception("MatrixTable.Round: \n" + ex.Message);
	}
}

// round sales to two digits after decimal point
SalaryTable = MatrixTable.Round(SalaryTable, 2);
 
// view SalaryTable with rounded key figures
MatrixTable.View_MatrixTable(SalaryTable, "SalaryTable with rounded figures");

/// <summary>
/// Aggregate all key figures of table over given attribute.
/// Applies the same aggregation method on all key figures.
/// </summary>
/// <param name="tbl">Input table</param>
/// <param name="AttributeField">Name of attribute (numeric or text) to be excluded from table</param>
/// <param name="AggrOpt">(sum, min, max or avg)</param>
/// <returns>Aggregated table</returns>
public static MatrixTable AggregateAttribute(MatrixTable tbl, string AttributeField,
	AggregateOption AggrOpt = AggregateOption.nSum)
{
	// PARAMETER CHECKS
	if (tbl == null || tbl.IsEmpty)
		throw new Exception("MatrixTable.AggregateAttribute: Null or empty input table!\n");
 
	if (AttributeField == null || AttributeField == "")
		throw new Exception("MatrixTable.AggregateAttribute: Null or empty string AttributeField!\n");
 
	// check if AttributeField is an attribute in table
	FieldType ftype = tbl.GetFieldType(AttributeField);
 
	if (ftype != FieldType.DateAttribute && ftype != FieldType.IntegerAttribute && ftype != FieldType.TextAttribute)
		throw new Exception("MatrixTable.AggregateAttribute: Given AttributeField is not an attribute of input table!\n");
 
	// check if table has at least one key figure to aggregate
	if (tbl.KeyFigureFields.IsEmpty)
		throw new Exception("MatrixTable.AggregateAttribute: Input table must have at least one key figure to aggregate!\n");
 
	// parameter checks OK, continue ...
	try
	{
		// exclude field AttributeField from table
		MatrixTable TblOut = MatrixTable.ExcludeColumns(tbl, 
			TextVector.CreateVectorWithElements(AttributeField));
 
		// aggregate all key figures
		return MatrixTable.AggregateAllKeyFigures(TblOut, null, AggrOpt);
	}
	catch (Exception ex)
	{
		throw new Exception("MatrixTable.AggregateAttribute: \n" + ex.Message);
	}
}

// aggregate salary over years
var AggregatedSalaryTable = MatrixTable.AggregateAttribute(SalaryTable, "year");
 
// view SalaryTable with salary aggregated over years
MatrixTable.View_MatrixTable(AggregatedSalaryTable, 
	"SalaryTable with aggregated salaries over years");

/// <summary>
/// Insert a new field and value to each row from a preceding or following row depending on RowOffset. 
/// A simple version SQL-based analytical functions like LEAD-LAG 
/// </summary>
/// <param name="InputTbl">Input table</param>
/// <param name="FieldName1">Field contained by input table whose preceding or following values are to be inserted</param>
/// <param name="FieldName2">New field to be inserted with values from preceding or following values rows</param>
/// <param name="RowOffset">Row offset: 1 means next row, -2 means previous of previous row, 0 means current row.</param>
/// <returns>Table with new field FieldName2 and values</returns>
public static MatrixTable InsertFieldValueFromAnotherRow(MatrixTable InputTbl,
	string FieldName1, string FieldName2, int RowOffset)
{
 
	#region "CHECK INPUT PARAMETERS"
	if (InputTbl == null || InputTbl.IsEmpty)    // IsEmpty means table has no fields
		throw new Exception("MatrixTable.InsertFieldValueFromAnotherRow: Null or empty input table!\n");
 
	MetaData md = InputTbl.metaData;
 
	// check if FieldName1 exists in input table
	if (InputTbl.GetFieldType(FieldName1) == FieldType.Undefined)
		throw new Exception("MatrixTable.InsertFieldValueFromAnotherRow: Field " + FieldName1 + " must exist input table!\n");
 
	// check if FieldName2 is defined in MetaData
	if (!MetaData.IfFieldExists(md, FieldName2))
		throw new Exception("MatrixTable.InsertFieldValueFromAnotherRow: Field " + FieldName2 + " is not defined in MetaData!\n");
 
	// check if FieldName2 exists in input table
	if (InputTbl.GetFieldType(FieldName2) != FieldType.Undefined)
		throw new Exception("MatrixTable.InsertFieldValueFromAnotherRow: Field " + FieldName2 + " must NOT exist input table!\n");
 
	// check field types
	if (md.GetFieldType(FieldName1) != md.GetFieldType(FieldName2))
		throw new Exception("MatrixTable.InsertFieldValueFromAnotherRow: Field1 and Field2 must have the same field types!\n");
 
	#endregion "CHECK INPUT PARAMETERS"
 
	// parameter checks done, continue ...
 
	// insert new field FieldName2 into InputTbl
	MatrixTable InputTblAdj = MatrixTable.InsertNewColumn(InputTbl, FieldName2);
 
	// create output table containing FieldName2
	var OutputTbl = MatrixTable.CreateEmptyTable(InputTblAdj.tableFields);
 
	// iterate over rows of input table
	int RowCount = InputTblAdj.RowCount;
	TableRow trow1, trow2;
 
	for (int i = 0; i < RowCount; i++)
	{
		trow1 = InputTblAdj.GetTableRow(i);
 
		if ((i + RowOffset) >= 0 && (i + RowOffset) <= (RowCount - 1))
		{
			trow2 = InputTblAdj.GetTableRow(i + RowOffset);
			TableRow.SetFieldValue(trow1, FieldName2, TableRow.GetFieldValue(trow2, FieldName1));
			OutputTbl = MatrixTable.AddRowToTable(OutputTbl, trow1);
		}
	}
	return OutputTbl;
}

// insert salary from previous year into salary table
SalaryTable = MatrixTable.InsertFieldValueFromAnotherRow(SalaryTable,
	"salary", "salary_prev_year", -1);
 
// view SalaryTable with salary from previous year
MatrixTable.View_MatrixTable(SalaryTable,
	"SalaryTable with salary from previous year");