Class {

#name : #DataFrame,

#superclass : #Collection,

#instVars : [

'contents',

'rowNames',

'columnNames',

'dataTypes'

],

#category : #'DataFrame-Core'

}

{ #category : #'instance creation' }

DataFrame class >> new: aPoint [

^ super new initialize: aPoint

]

{ #category : #'instance creation' }

DataFrame class >> withColumnNames: anArrayOfColumnNames [

"Create an empty data frame with given column names"

| numberOfColumns df |

numberOfColumns := anArrayOfColumnNames size.

df := self new: 0 @ numberOfColumns.

df columnNames: anArrayOfColumnNames.

^ df

]

{ #category : #'instance creation' }

DataFrame class >> withColumnNames: anArrayOfColumnNames withRowNames: anArrayOfRowNames [

"Create an empty data frame with given column and row names"

| numberOfColumns numberOfRows df |

numberOfColumns := anArrayOfColumnNames size.

numberOfRows := anArrayOfRowNames size.

df := self new: numberOfRows @ numberOfColumns.

df columnNames: anArrayOfColumnNames.

df rowNames: anArrayOfRowNames.

^ df

]

{ #category : #'instance creation' }

DataFrame class >> withColumns: anArrayOfArrays [

^ self new initializeColumns: anArrayOfArrays

]

{ #category : #'instance creation' }

DataFrame class >> withColumns: anArrayOfArrays columnNames: anArrayOfColumnNames [

| df |

df := self withColumns: anArrayOfArrays.

df columnNames: anArrayOfColumnNames.

^ df

]

{ #category : #'instance creation' }

DataFrame class >> withColumns: anArrayOfArrays rowNames: anArrayOfRowNames [

^ anArrayOfArrays

ifNotEmpty: [ (self withColumns: anArrayOfArrays)

rowNames: anArrayOfRowNames;

yourself ]

ifEmpty: [ self withRowNames: anArrayOfRowNames ]

]

{ #category : #'instance creation' }

DataFrame class >> withColumns: anArrayOfArrays rowNames: anArrayOfRowNames columnNames: anArrayOfColumnNames [

^ anArrayOfArrays

ifNotEmpty: [ (self withColumns: anArrayOfArrays)

rowNames: anArrayOfRowNames;

columnNames: anArrayOfColumnNames;

yourself ]

ifEmpty: [ self withRowNames: anArrayOfRowNames ]

]

{ #category : #'instance creation' }

DataFrame class >> withDataFrameInternal: aDataFrameIndernal rowNames: rows columnNames: columns [

^ self new

initializeContents: aDataFrameIndernal

rowNames: rows

columnNames: columns

]

{ #category : #'instance creation' }

DataFrame class >> withRowNames: anArrayOfRowNames [

"Create an empty data frame with given row names"

| numberOfRows df |

numberOfRows := anArrayOfRowNames size.

df := self new: numberOfRows @ 0.

df rowNames: anArrayOfRowNames.

^ df

]

{ #category : #'instance creation' }

DataFrame class >> withRowNames: anArrayOfRowNames columnNames: anArrayOfColumnNames [

"Create an empty data frame with given row and column names"

| numberOfRows numberOfColumns df |

numberOfRows := anArrayOfRowNames size.

numberOfColumns := anArrayOfColumnNames size.

df := self new: numberOfRows @ numberOfColumns.

df rowNames: anArrayOfRowNames.

df columnNames: anArrayOfColumnNames.

^ df

]

{ #category : #'instance creation' }

DataFrame class >> withRows: anArrayOfArrays [

^ self new initializeRows: anArrayOfArrays

]

{ #category : #'instance creation' }

DataFrame class >> withRows: anArrayOfArrays columnNames: anArrayOfColumnNames [

^ anArrayOfArrays

ifNotEmpty: [ (self withRows: anArrayOfArrays)

columnNames: anArrayOfColumnNames;

yourself ]

ifEmpty: [ self withColumnNames: anArrayOfColumnNames ]

]

{ #category : #'instance creation' }

DataFrame class >> withRows: anArrayOfArrays rowNames: anArrayOfRowNames [

| df |

df := self withRows: anArrayOfArrays.

df rowNames: anArrayOfRowNames.

^ df

]

{ #category : #'instance creation' }

DataFrame class >> withRows: anArrayOfArrays rowNames: anArrayOfRowNames columnNames: anArrayOfColumnNames [

^ anArrayOfArrays

ifNotEmpty: [ (self withRows: anArrayOfArrays)

rowNames: anArrayOfRowNames;

columnNames: anArrayOfColumnNames;

yourself ]

ifEmpty: [ self withColumnNames: anArrayOfColumnNames ]

]

{ #category : #comparing }

DataFrame >> = aDataFrame [

"Most objects will fail here"

aDataFrame species = self species

ifFalse: [ ^ false ].

"This is the fastest way for two data frames with different dimensions"

aDataFrame dimensions = self dimensions

ifFalse: [ ^ false ].

"If the names are different we don't need to iterate through values"

(aDataFrame rowNames = self rowNames

and: [ aDataFrame columnNames = self columnNames ])

ifFalse: [ ^ false ].

^ aDataFrame contents = self contents

]

{ #category : #adding }

DataFrame >> add: aDataSeries [

"Add DataSeries as a new row at the end"

self flag:

'This mathod name is not correct. It is misleading. We should think if we should delete it or keep it'.

self addRow: aDataSeries

]

{ #category : #adding }

DataFrame >> addColumn: aDataSeries [

"Add DataSeries as a new column at the end"

self addColumn: aDataSeries named: aDataSeries name.

(self dataTypes ) at: aDataSeries name put: aDataSeries calculateDataType

]

{ #category : #adding }

DataFrame >> addColumn: aDataSeries atPosition: aNumber [

"Add DataSeries as a new column at the given position"

self addColumn: aDataSeries asArray named: aDataSeries name atPosition: aNumber

]

{ #category : #adding }

DataFrame >> addColumn: anArray named: aString [

"Add a new column at the end"

self addColumn: anArray named: aString atPosition: self numberOfColumns + 1

]

{ #category : #adding }

DataFrame >> addColumn: anArray named: aString atPosition: aNumber [

"Add a new column at the given position"

(self columnNames includes: aString)

ifTrue: [ Error signal: 'A column with that name already exists' ].

contents addColumn: anArray asArray atPosition: aNumber.

columnNames add: aString afterIndex: aNumber - 1.

dataTypes at: aString put: (anArray asDataSeries calculateDataType)

]

{ #category : #adding }

DataFrame >> addEmptyColumnNamed: aString [

"Add an empty column at the end"

self addEmptyColumnNamed: aString atPosition: self numberOfColumns + 1

]

{ #category : #adding }

DataFrame >> addEmptyColumnNamed: aString atPosition: aNumber [

"Add an empty column at the given position"

self addColumn: (Array new: self numberOfRows) named: aString atPosition: aNumber

]

{ #category : #adding }

DataFrame >> addEmptyRowNamed: aString [

"Add an empty row at the end"

self addEmptyRowNamed: aString atPosition: self numberOfRows + 1

]

{ #category : #adding }

DataFrame >> addEmptyRowNamed: aString atPosition: aNumber [

"Add an empty row at the given position"

self addRow: (Array new: self numberOfColumns) named: aString atPosition: aNumber

]

{ #category : #adding }

DataFrame >> addRow: aDataSeries [

"Add DataSeries as a new row at the end"

self addRow: aDataSeries asArray named: aDataSeries name

]

{ #category : #adding }

DataFrame >> addRow: aDataSeries atPosition: aNumber [

"Add DataSeries as a new row at the given position"

self addRow: aDataSeries named: aDataSeries name atPosition: aNumber

]

{ #category : #adding }

DataFrame >> addRow: anArray named: aString [

"Add a new row at the end"

self addRow: anArray named: aString atPosition: self numberOfRows + 1

]

{ #category : #adding }

DataFrame >> addRow: anArray named: aString atPosition: aNumber [

"Add a new row at the given position"

(self rowNames includes: aString)

ifTrue: [ Error signal: 'A row with that name already exists' ].

contents addRow: anArray atPosition: aNumber.

rowNames add: aString afterIndex: aNumber - 1

]

{ #category : #plot }

DataFrame >> addScatterPlotShapeToChart: aRSChart [

" Assume a receiver with two first columns as x and y coordinates.

| scatterPlot x y |

x := (self columnAt: 1) asOrderedCollection.

y := (self columnAt: 2) asOrderedCollection.

scatterPlot := RSScatterPlot new x: x y: y.

aRSChart addPlot: scatterPlot.

^ scatterPlot

]

{ #category : #applying }

DataFrame >> applyElementwise: aBlock [

"Applies a given block to all columns of a data frame"

self toColumns: self columnNames applyElementwise: aBlock

]

{ #category : #enumerating }

DataFrame >> applySize [

"Answer a new instance of the receiver with the size of each element at each element position"

^ self collectWithIndex: [ :r :i |

DataSeries

withValues: (r values collect: [ : e | e ifNil: [ 0 ] ifNotNil: [ e size ]])

name: i ]

]

{ #category : #private }

DataFrame >> applyToAllColumns: aSymbol [

| series column |

series := DataSeries withValues:

(self columnNames collect: [ :colName |

column := self column: colName.

column perform: aSymbol ]).

series name: aSymbol.

series keys: self columnNames.

^ series

]

{ #category : #converting }

DataFrame >> asArray [

"Converts DataFrame to the array of rows"

^ self asArrayOfRows

]

{ #category : #converting }

DataFrame >> asArrayOfColumns [

"Converts DataFrame to the array of columns"

^ contents asArrayOfColumns.

]

{ #category : #converting }

DataFrame >> asArrayOfRows [

"Converts DataFrame to the array of rows"

^ contents asArrayOfRows

]

{ #category : #converting }

DataFrame >> asArrayOfRowsWithName [

"Answer an OrderedCollection where each item is an Array with:

^ self rowNames withIndexCollect: [ :name :index |

Array streamContents: [ :stream |

stream nextPut: name;

nextPutAll: (self at: index) ] ]

]

{ #category : #accessing }

DataFrame >> at: aNumber [

"Returns the row of a DataFrame at row index aNumber"

^ self rowAt: aNumber

]

{ #category : #accessing }

DataFrame >> at: rowNumber at: columnNumber [

"Returns the value whose row index is rowNumber and column index is columnNumber"

^ contents at: rowNumber at: columnNumber

]

{ #category : #accessing }

DataFrame >> at: rowNumber at: columnNumber put: value [

"Replaces the original value of a DataFrame at row index rowNumber and column index columnNumber with a given value"

contents at: rowNumber at: columnNumber put: value

]

{ #category : #accessing }

DataFrame >> at: rowIndex at: columnIndex transform: aBlock [

"Evaluate aBlock on the value at the intersection of rowIndex and columnIndex and replace that value with the result"

| value |

value := self at: rowIndex at: columnIndex.

self at: rowIndex at: columnIndex put: (aBlock value: value)

]

{ #category : #accessing }

DataFrame >> at: aNumber transform: aBlock [

"Evaluate aBlock on the row at aNumber and replace that row with the result"

^ self rowAt: aNumber transform: aBlock

]

{ #category : #accessing }

DataFrame >> atAll: indexes [

"For polymorphisme with other collections."

^ self rowsAt: indexes

]

{ #category : #statistics }

DataFrame >> average [

"Average is the ratio of sum of values in a set to the number of values in the set"

^ self applyToAllColumns: #average

]

{ #category : #'data-types' }

DataFrame >> calculateDataTypes [

self columns doWithIndex: [ :column :i | self dataTypes at: (self columnNames at: i) put: column calculateDataType ]

]

{ #category : #comparing }

DataFrame >> closeTo: aDataFrame [

aDataFrame species = self species

ifFalse: [ ^ false ].

aDataFrame dimensions = self dimensions

ifFalse: [ ^ false ].

(aDataFrame rowNames = self rowNames

and: [ aDataFrame columnNames = self columnNames ])

ifFalse: [ ^ false ].

1 to: self numberOfRows do: [ :i |

1 to: self numberOfColumns do: [ :j |

((self at: i at: j) closeTo: (aDataFrame at: i at: j))

ifFalse: [ ^ false ] ] ].

^ true

]

{ #category : #enumerating }

DataFrame >> collect: aBlock [

"Overrides the Collection>>collect to create DataFrame with the same number of columns as values in the first row"

| firstRow newDataFrame |

firstRow := aBlock value: (self rowAt: 1) copy.

newDataFrame := self class new: 0@firstRow size.

newDataFrame columnNames: firstRow keys.

self do: [:each | newDataFrame add: (aBlock value: each copy)].

^ newDataFrame

]

{ #category : #enumerating }

DataFrame >> collectWithIndex: aBlock [

"Overrides the Collection>>collect to create DataFrame with the same number of columns as values in the first row"

| firstRow newDataFrame |

firstRow := aBlock value: (self rowAt: 1) copy value: 1.

newDataFrame := self class new: 0@firstRow size.

newDataFrame columnNames: firstRow keys.

self doWithIndex: [ : each : index | newDataFrame add: (aBlock value: each copy value: index) ].

^ newDataFrame

]

{ #category : #accessing }

DataFrame >> column: columnName [

"Answer the column with columnName as a DataSeries or signal an exception if a column with that name was not found"

| index |

index := self indexOfColumnNamed: columnName.

^ self columnAt: index

]

{ #category : #accessing }

DataFrame >> column: columnName ifAbsent: exceptionBlock [

"Answer the column with columnName as a DataSeries or evaluate exception block if a column with that name was not found"

| index |

index := self

indexOfColumnNamed: columnName

ifAbsent: [ ^ exceptionBlock value ].

^ self columnAt: index

]

{ #category : #accessing }

DataFrame >> column: columnName put: anArray [

"Replace the current values of column with columnName with anArray or signal an exception if a column with that name was not found"

| index |

index := self indexOfColumnNamed: columnName.

^ self columnAt: index put: anArray

]

{ #category : #accessing }

DataFrame >> column: columnName put: anArray ifAbsent: exceptionBlock [

"Replace the current values of column with columnName with anArray or evaluate exception block if a column with that name was not found"

| index |

index := self

indexOfColumnNamed: columnName

ifAbsent: [ ^ exceptionBlock value ].

^ self columnAt: index put: anArray

]

{ #category : #accessing }

DataFrame >> column: columnName transform: aBlock [

"Evaluate aBlock on the column with columnName and replace column with the result. Signal an exception if columnName was not found"

| column |

column := self column: columnName.

self column: columnName put: (aBlock value: column) asArray

]

{ #category : #accessing }

DataFrame >> column: columnName transform: aBlock ifAbsent: exceptionBlock [

"Evaluate aBlock on the column with columnName and replace column with the result. Evaluate exceptionBlock if columnName was not found"

| column |

column := self column: columnName ifAbsent: [ ^ exceptionBlock value ].

self column: columnName put: (aBlock value: column)

]

{ #category : #accessing }

DataFrame >> columnAt: aNumber [

"Returns the column of a DataFrame at column index aNumber"

^ (DataSeries withKeys: self rowNames values: (contents columnAt: aNumber))

name: (self columnNames at: aNumber);

yourself

]

{ #category : #accessing }

DataFrame >> columnAt: aNumber put: anArray [

"Replaces the column at column index aNumber with contents of the array anArray"

anArray size = self numberOfRows

ifFalse: [ SizeMismatch signal ].

contents columnAt: aNumber put: anArray

]

{ #category : #accessing }

DataFrame >> columnAt: aNumber transform: aBlock [

"Evaluate aBlock on the column at aNumber and replace that column with the result"

| column |

column := self columnAt: aNumber.

self columnAt: aNumber put: (aBlock value: column) asArray

]

{ #category : #accessing }

DataFrame >> columnNames [

"Returns the column names of a DataFrame"

^ columnNames

]

{ #category : #accessing }

DataFrame >> columnNames: aCollection [

"Sets the column names of a DataFrame with contents of the collection aCollection"

| type |

aCollection size = self numberOfColumns

ifFalse: [ SizeMismatch signal: 'Wrong number of column names' ].

aCollection asSet size = aCollection size

ifFalse: [ Error signal: 'All column names must be distinct' ].

self columnNames ifNotNil: [

self columnNames withIndexDo: [ :currentColumnName :i |

type := dataTypes at: currentColumnName.

dataTypes removeKey: currentColumnName.

dataTypes at: (aCollection at: i) put: type ] ].

columnNames := aCollection asOrderedCollection

]

{ #category : #accessing }

DataFrame >> columns [

"Returns a collection of all columns"

^ self asArrayOfColumns

]

{ #category : #accessing }

DataFrame >> columns: anArrayOfNames [

"Returns a collection of columns whose column names are present in the array anArrayOfNames"

| anArrayOfNumbers |

anArrayOfNumbers := anArrayOfNames

collect: [ :name |

self indexOfColumnNamed: name ].

^ self columnsAt: anArrayOfNumbers

]

{ #category : #accessing }

DataFrame >> columns: anArrayOfColumnNames put: anArrayOfArrays [

"Replaces the columns whose column names are present in the array anArrayOfColumnNames with the contents of the array of arrays anArrayOfArrays"

anArrayOfArrays size = anArrayOfColumnNames size

ifFalse: [ SizeMismatch signal ].

anArrayOfColumnNames with: anArrayOfArrays do: [ :name :array |

self column: name put: array ]

]

{ #category : #accessing }

DataFrame >> columnsAt: anArrayOfNumbers [

"Returns a collection of columns whose column indices are present in the array anArrayOfNumbers"

| newColumnNames |

newColumnNames := (anArrayOfNumbers collect: [ :i |

self columnNames at: i ]).

^ DataFrame

withDataFrameInternal: (self contents columnsAt: anArrayOfNumbers)

rowNames: self rowNames

columnNames: newColumnNames

]

{ #category : #accessing }

DataFrame >> columnsAt: anArrayOfNumbers put: anArrayOfArrays [

"Replaces the columns whose column indices are present in the array anArrayOfNumbers with the contents of the array of arrays anArrayOfArrays"

anArrayOfArrays size = anArrayOfNumbers size

ifFalse: [ SizeMismatch signal ].

anArrayOfNumbers with: anArrayOfArrays do: [ :index :array |

self columnAt: index put: array ]

]

{ #category : #accessing }

DataFrame >> columnsFrom: begin to: end [

"Returns a collection of columns whose column indices are present between begin and end"

| array |

array := begin < end

ifTrue: [ (begin to: end) asArray ]

ifFalse: [ (end to: begin) asArray reverse ].

^ self columnsAt: array

]

{ #category : #accessing }

DataFrame >> columnsFrom: firstNumber to: secondNumber put: anArrayOfArrays [

"Replaces the columns whose column indices are present between firstNumber and secondNumber with the contents of the array of arrays anArrayOfArrays"

| interval |

anArrayOfArrays size = ((firstNumber - secondNumber) abs + 1)

ifFalse: [ SizeMismatch signal ].

interval := secondNumber >= firstNumber

ifTrue: [ (firstNumber to: secondNumber) ]

ifFalse: [ (secondNumber to: firstNumber) reversed ].

interval withIndexDo: [ :columnIndex :i |

self columnAt: columnIndex put: (anArrayOfArrays at: i) ]

]

{ #category : #accessing }

DataFrame >> contents [

"Returns all the values of the DataFrame"

^ contents

]

{ #category : #copying }

DataFrame >> copyReplace: missingValue in2DCollectionBy: arrayOfReplacementValues [

"I am a 2D collection and the goal is to return a copy replace the missing values by the values of my second parameter. The good value is the index of the missing value in the sub collection.

| copy |

copy := self copy.

1 to: self numberOfColumns do: [ :columnIndex |

| replacementValue |

replacementValue := arrayOfReplacementValues at: columnIndex.

1 to: self numberOfRows do: [ :rowIndex | (self at: rowIndex at: columnIndex) = missingValue ifTrue: [ self copy at: rowIndex at: columnIndex put: replacementValue ] ] ].

^ copy

]

{ #category : #statistics }

DataFrame >> correlationMatrix [

"Calculate a correlation matrix (correlation of every column with every column) using Pearson's correlation coefficient"

^ self correlationMatrixUsing: DataPearsonCorrelationMethod

]

{ #category : #statistics }

DataFrame >> correlationMatrixUsing: aCorrelationCoefficient [

"Calculate a correlation matrix (correlation of every column with every column) using the given correlation coefficient"

| numericalColumnNames correlationMatrix firstColumn secondColumn correlation |

numericalColumnNames := self columnNames select: [ :columnName |

(self column: columnName) isNumerical ].

numericalColumnNames ifEmpty: [

Error signal: 'This data frame does not have any numerical columns' ].

correlationMatrix := self class

withRowNames: numericalColumnNames

columnNames: numericalColumnNames.

1 to: numericalColumnNames size do: [ :i |

1 to: i - 1 do: [ :j |

firstColumn := self column: (numericalColumnNames at: i).

secondColumn := self column: (numericalColumnNames at: j).

correlation := firstColumn correlationWith: secondColumn using: aCorrelationCoefficient.

correlationMatrix at: i at: j put: correlation.

correlationMatrix at: j at: i put: correlation ] ].

1 to: numericalColumnNames size do: [ :i |

correlationMatrix at: i at: i put: 1 ].

^ correlationMatrix

]

{ #category : #accessing }

DataFrame >> crossTabulate: colName1 with: colName2 [

"Returns the cross tabulation of a column named colName1 with the column named colName2 of the DataFrame"

| col1 col2 |

col1 := self column: colName1.

col2 := self column: colName2.

^ col1 crossTabulateWith: col2

]

{ #category : #copying }

DataFrame >> dataPreProcessingEncodeWith: anEncoder [

"This method is here to speed up pharo-ai/data-preprocessing algos without coupling both projects."

| copy cache |

copy := self copy.

cache := IdentityDictionary new.

self columns doWithIndex: [ :dataSerie :columnIndex |

| category |

category := cache at: columnIndex ifAbsentPut: [ ((anEncoder categories at: columnIndex) collectWithIndex: [ :elem :index | elem -> index ]) asDictionary ].

dataSerie doWithIndex: [ :element :rowIndex |

copy at: rowIndex at: columnIndex put: (category at: element ifAbsent: [ AIMissingCategory signalFor: element ]) ] ].

^ copy

]

{ #category : #'data-types' }

DataFrame >> dataTypeOfColumn: aColumnName [

"Given a column name of the DataFrame, it returns the data type of that column"

^ dataTypes at: aColumnName

]

{ #category : #'data-types' }

DataFrame >> dataTypeOfColumn: aColumnName put: aDataType [

"Given a column name and a data type, it replaces the original data type of that column with the data type that was given as a parameter"

dataTypes at: aColumnName put: aDataType

]

{ #category : #'data-types' }

DataFrame >> dataTypeOfColumnAt: aNumber [

"Given a column index of the DataFrame, it returns the data type of that column"

^ self dataTypeOfColumn: (columnNames at: aNumber)

]

{ #category : #'data-types' }

DataFrame >> dataTypeOfColumnAt: aNumber put: aDataType [

"Given a column index and a data type, it replaces the original data type of that column with the data type that was given as a parameter"

^ self dataTypeOfColumn: (columnNames at: aNumber) put: aDataType

]

{ #category : #accessing }

DataFrame >> dataTypes [

"Returns the data types of each column"

^ dataTypes

]

{ #category : #accessing }

DataFrame >> dataTypes: anObject [

dataTypes := anObject

]

{ #category : #accessing }

DataFrame >> defaultHeadTailSize [

^ 5

]

{ #category : #accessing }

DataFrame >> dimensions [

"Returns the number of rows and number of columns in a DataFrame"

^ (self numberOfRows) @ (self numberOfColumns)

]

{ #category : #enumerating }

DataFrame >> do: aBlock [

| row |

1 to: self numberOfRows do: [ :i |

row := self rowAt: i.

aBlock value: row.

"A hack to allow modification of rows inside do block"

self rowAt: i put: row asArray ]

]

{ #category : #'find-select' }

DataFrame >> findAll: anObject atColumn: columnName [

"Returns rowNames of rows having anObject at columnName"

^ self rowNames select: [ :row | ((self column: columnName) at: row) = anObject ]

]

{ #category : #'find-select' }

DataFrame >> findAllIndicesOf: anObject atColumn: columnName [

"Returns indices of rows having anObject at columnName"

| output |

output := OrderedCollection new.

self rowNames withIndexDo: [ :row :index | ((self column: columnName) at: row) = anObject ifTrue: [ output add: index ]].

^ output

]

{ #category : #accessing }

DataFrame >> first [

"Returns the first row of the DataFrame"

^ self at: 1

]

{ #category : #statistics }

DataFrame >> firstQuartile [

"25% of the values in a set are smaller than or equal to the first Quartile of that set"

^ self applyToAllColumns: #firstQuartile

]

{ #category : #private }

DataFrame >> getJointColumnsWith: aDataFrame [

"comment stating purpose of message"

| columnIntersection outputColumns |

columnIntersection := (self columnNames intersection: (aDataFrame columnNames)) asSet.

outputColumns := OrderedCollection new.

self columnNames do: [ :column |

(columnIntersection includes: column)

ifTrue: [ outputColumns add: ('' join: {column, '_x'}) ]

ifFalse: [ outputColumns add: column ]

].

aDataFrame columnNames do: [ :column |

(columnIntersection includes: column)

ifTrue: [ outputColumns add: ('' join: {column, '_y'}) ]

ifFalse: [ outputColumns add: column ]

].

^ outputColumns

]

{ #category : #grouping }

DataFrame >> group: anAggregateColumnName by: aGroupColumnName aggregateUsing: aBlock [

"Group the values of the cloumn named anAggregateColumnName by the unique values of the column named aGroupColumnName, aggregate them using aBlock. With the same name as anAggregateColumnName"