# NMath User's Guide

37.10 Factors (.NET, C#, CSharp, VB, Visual Basic, F#)

The class represents a categorical vector in which all elements are drawn from a finite number of factor levels. Thus, a Factor contains two parts:

an object array of factor levels

an integer array of categorical data, of which each element is an index into the array of levels

For example, this string data:

```"A", "A", "C", "B", "A", "C", "B"
```

could be presented as a Factor with the following levels and categorical data:

Code Example – C#

```object[] levels = { "A", "B", "C" };
```
```int[] data = { 0, 0, 2, 1, 0, 2, 1 };
```

Code Example – VB

```Dim Levels As Object() = {"A", "B", "C"}
```
```Dim Data As Integer() = {0, 0, 2, 1, 0, 2, 1}
```

Factors are usually constructed from a data frame column using the GetFactor() method, but they can also be constructed independently.

Creating Factors

The GetFactor() method on DataFrame accepts a column index or name and returns a Factor with levels for the sorted, unique elements in the given column:

Code Example – C#

```Factor myColFactor = df.GetFactor( "myCol" );
```

Code Example – VB

```Dim ColFactor As Factor = DF.GetFactor("myCol")
```

Alternatively, you can provide the factor levels yourself. The order is preserved. Thus:

Code Example – C#

```var levels = new object[] { "Q1", "Q2", "Q3", "Q4" };
```
```Factor myColFactor = df.GetFactor( "myCol", levels );
```

Code Example – VB

```Dim Levels As Object() = {"Q1", "Q2", "Q3", "Q4"}
```
```Dim ColFactor As Factor = DF.GetFactor("myCol", Levels)
```

An InvalidArgumentException is raised if the specified column contains a value not present in the given array of levels.

You can also construct a Factor independently of a DataFrame. For example, you can construct a Factor from an array of values:

Code Example – C#

```var strArray = new object[] { 1, 1, 3, 2, 1, 3, 2 };
```
```var factor = new Factor( strArray );
```

Code Example – VB

```Dim StrArray As Object() = {1, 1, 3, 2, 1, 3, 2}
```
```Dim Factor As New Factor(StrArray)
```

Factor levels are constructed from a sorted list of unique values in the passed array.

Alternatively, you can construct a Factor from an array of factor levels, and a data array consisting of indices into the factor levels:

Code Example – C#

```var levels = new object[] { 1, 2, 3 };
```
```var data = new int[] { 0, 0, 2, 1, 0, 2, 1 };
```
```var factor = new Factor( levels, data );
```

Code Example – VB

```Dim Levels As Object() = {1, 2, 3}
```
```Dim Data As Integer() = {0, 0, 2, 1, 0, 2, 1}
```
```Dim Factor As New Factor(Levels, Data)
```

An InvalidArgumentException is thrown if the given data array contains an invalid index.

Properties of Factors

The Factor class provides the following properties:

Data gets the categorical data for the factor. Each element in the returned integer array is an index into Levels.

Levels gets the levels of the factor as an array of objects.

Length gets the length of the Data in the factor.

Name gets and set the name of the factor.

NumberOfLevels gets the number of levels in the factor.

Accessing Factors

A standard indexer is provided for accessing the element at a given index:

Code Example – C#

```string str = (string)factor;
```

Code Example – VB

```Dim Str As String = CType(Factor(2), String)
```

The indexer returns Levels[ Data[index] ]—that is, it returns the level at the given position.

Creating Groupings with Factors

The principal use of factors is in conjunction with the GetGroupings() methods on Subset. One overload of this method accepts a single Factor and returns an array of subsets containing the indices for each level of the given factor. Another overload accepts two Factor objects and returns a two-dimensional jagged array of subsets containing the indices for each combination of levels in the two factors.

For example, suppose we weigh human subjects based on sex and age group. The data for 15 subject might look like this:

Table 26 – Sample data

 Male Female Child 45, 42 30, 35, 60, 40 Adult 182, 170 115, 130, 110 Senior 142, 155 115, 123

In a DataFrame, each observation would be a row, like so:

Code Example – C#

```var df = new DataFrame();
```
```df.AddColumn( new DFStringColumn( "Sex" ) );
```
```df.AddColumn( new DFStringColumn( "AgeGroup" ));
```
```df.AddColumn( new DFIntColumn( "Weight" ) );

```

```df.AddRow( "John Smith", "Male", "Child", 45 );
```
```df.AddRow( "Ruth Barnes", "Female", "Senior", 115 );
```
```df.AddRow( "Jane Jones", "Female", "Adult", 115 );
```
```df.AddRow( "Timmy Toddler", "Male", "Child", 42 );
```
```df.AddRow( "Betsy Young", "Female", "Adult", 130 );
```
```df.AddRow( "Arthur Smith", "Male", "Senior", 142 );
```
```df.AddRow( "Lucy Young", "Female", "Child", 30 );
```
```df.AddRow( "Emma Allen", "Female", "Child", 35 );
```
```df.AddRow( "Roy Wilkenson", "Male", "Adult", 182 );
```
```df.AddRow( "Susan Schwarz", "Female", "Senior", 110 );
```
```df.AddRow( "Ming Tao", "Female", "Senior", 123 );
```
```df.AddRow( "Johanna Glynn", "Female", "Child", 60 );
```
```df.AddRow( "Randall Harvey", "Male", "Adult", 170 );
```
```df.AddRow( "Tom Howard", "Male", "Senior", 155 );
```
```df.AddRow( "Jennifer Watson", "Female", "Child", 40 );
```

Code Example – VB

```Dim DF As New DataFrame()
```
```DF.AddColumn(New DFStringColumn("Sex"))
```
```DF.AddColumn(New DFStringColumn("AgeGroup"))
```
```DF.AddColumn(New DFIntColumn("Weight"))

```

```DF.AddRow("John Smith", "Male", "Child", 45)
```
```DF.AddRow("Ruth Barnes", "Female", "Senior", 115)
```
```DF.AddRow("Jane Jones", "Female", "Adult", 115)
```
```DF.AddRow("Timmy Toddler", "Male", "Child", 42)
```
```DF.AddRow("Betsy Young", "Female", "Adult", 130)
```
```DF.AddRow("Arthur Smith", "Male", "Senior", 142)
```
```DF.AddRow("Lucy Young", "Female", "Child", 30)
```
```DF.AddRow("Emma Allen", "Female", "Child", 35)
```
```DF.AddRow("Roy Wilkenson", "Male", "Adult", 182)
```
```DF.AddRow("Susan Schwarz", "Female", "Senior", 110)
```
```DF.AddRow("Ming Tao", "Female", "Senior", 123)
```
```DF.AddRow("Johanna Glynn", "Female", "Child", 60)
```
```DF.AddRow("Randall Harvey", "Male", "Adult", 170)
```
```DF.AddRow("Tom Howard", "Male", "Senior", 155)
```
```DF.AddRow("Jennifer Watson", "Female", "Child", 40)
```

In this case, we're using the subjects' names as row keys.

It is natural to construct factors from the Sex and AgeGroup columns:

Code Example – C#

```Factor sex = df.GetFactor( "Sex" );
```
```Factor age = df.GetFactor( "AgeGroup" );
```

Code Example – VB

```Dim Sex As Factor = DF.GetFactor("Sex")
```
```Dim Age As Factor = DF.GetFactor("AgeGroup")
```

We can then use these factors in conjunction with the GetGroupings() methods on Subset to create subsets representing the original rows, columns, and cells in Table 26:

Code Example – C#

```Subset[] sexGroups = Subset.GetGroupings( sex );
```
```Subset[] ageGroups = Subset.GetGroupings( age );
```
```Subset[,] cellGroups = Subset.GetGroupings( sex, age );
```

Code Example – VB

```Dim SexGroups As Subset() = Subset.GetGroupings(Sex)
```
```Dim AgeGroups As Subset() = Subset.GetGroupings(Age)
```
```Dim CellGroups As Subset(,) = Subset.GetGroupings(Sex, Age)
```

These subsets can then be used to operate on the relevant portions of the data frame. For instance, this code prints out row means, column means, and cell means for Table 26:

Code Example – C#

```Console.WriteLine( "\nTABLE ROW MEANS" );
```
```for ( int i = 0; i < age.NumberOfLevels; i++ )
```
```{
```
```  double mean = StatsFunctions.Mean(
```
```    df[ df.IndexOfColumn( "Weight" ), ageGroups[i] ] );
```
```  Console.WriteLine( "Mean for {0} = {1}", age.Levels[i], mean );
```
```}

```

```Console.WriteLine( "\nTABLE COLUMN MEANS" );
```
```for ( int i = 0; i < sex.NumberOfLevels; i++ )
```
```{
```
```  double mean = StatsFunctions.Mean(
```
```    df[ df.IndexOfColumn( "Weight" ), sexGroups[i] ] );
```
```  Console.WriteLine( "Mean for {0} = {1}", sex.Levels[i], mean );
```
```}

```

```Console.WriteLine( "\nTABLE CELL MEANS" );
```
```for ( int i = 0; i < sex.NumberOfLevels; i++ )
```
```{
```
```  for ( int j = 0; j < age.NumberOfLevels; j++ )
```
```  {
```
```    double mean = StatsFunctions.Mean(
```
```      df[ df.IndexOfColumn( "Weight" ), cellGroups[i,j] ] );
```
```    Console.WriteLine( "Mean for {0} {1} = {2}",
```
```      sex.Levels[i], age.Levels[j], mean );
```
```  }
```
```}
```

Code Example – VB

```Console.WriteLine(Environment.NewLine & "TABLE ROW MEANS")
```
```For I As Integer = 0 To Age.NumberOfLevels - 1
```
```  Dim Mean As Double =
```
```    StatsFunctions.Mean(DF(DF.IndexOfColumn("Weight"),
```
```    AgeGroups(I)))
```
```  Console.WriteLine("Mean for {0} = {1}", Age.Levels(I), Mean)
```
```Next

```

```Console.WriteLine(Environment.NewLine & "TABLE COLUMN MEANS")
```
```For I As Integer = 0 To Sex.NumberOfLevels - 1
```
```  Dim Mean As Double =
```
```    StatsFunctions.Mean(DF(DF.IndexOfColumn("Weight"),
```
```    SexGroups(I)))

```

```  Console.WriteLine("Mean for {0} = {1}", Sex.Levels(I), Mean)
```
```Next

```

```Console.WriteLine(Environment.NewLine & "TABLE CELL MEANS")
```
```For I As Integer = 0 To Sex.NumberOfLevels - 1
```
```  For J As Integer = 0 To Age.NumberOfLevels - 1
```
```    Dim Mean As Double =
```
```      StatsFunctions.Mean(DF(DF.IndexOfColumn("Weight"),
```
```      CellGroups(I, J)))
```
```    Console.WriteLine("Mean for {0} {1} = {2}", Sex.Levels(I),
```
```      Age.Levels(J), Mean)
```
```  Next
```
```Next
```

The output is:

```TABLE ROW MEANS
```
```Mean for Adult = 149.25
```
```Mean for Child = 42
```
```Mean for Senior = 129

```

```TABLE COLUMN MEANS
```
```Mean for Female = 84.2222222222222
```
```Mean for Male = 122.666666666667

```

```TABLE CELL MEANS
```
```Mean for Female Adult = 122.5
```
```Mean for Female Child = 41.25
```
```Mean for Female Senior = 116
```
```Mean for Male Adult = 176
```
```Mean for Male Child = 43.5
```
```Mean for Male Senior = 148.5
```

See also the Tabulate() convenience methods on class DataFrame, as described in Section 37.11.

Top

Top