Class {

#name : 'DataFrame',

#superclass : 'Collection',

#instVars : [

'contents',

'rowNames',

'columnNames',

'dataTypes'

],

#category : 'DataFrame-Core',

#package : 'DataFrame',

#tag : '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 [

| dataFrame rows |

self columnNames = aDataFrame columnNames ifFalse: [ self error: 'Not yet supported.' ].

(self rowNames includesAny: aDataFrame rowNames) ifTrue: [ self error: 'Not yet supported.' ].

dataFrame := self copy.

rows := aDataFrame asArrayOfRows.

aDataFrame rowNames doWithIndex: [ :name :index | dataFrame addRow: (rows at: index) named: name ].

^ dataFrame

]

{ #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"

"(#(#(1 2) #(3 4)) asDataFrame addColumn: #(5 6) asDataSeries named: 3) >>> (#(#(1 2 5) #(3 4 6)) asDataFrame)"

"(#(#(r1c1 r1c2)) asDataFrame addColumn: #(r1c3) asDataSeries named: 3) >>> (#(#(r1c1 r1c2 r1c3)) asDataFrame)"

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"

"(#(#(1 2) #(3 4)) asDataFrame addColumn: #(5 6) asDataSeries named: 3 atPosition: 3) >>> (#(#(1 2 5) #(3 4 6)) asDataFrame)"

"(#(#(r1c1 r1c2)) asDataFrame addColumn: #(r1c3) asDataSeries named: 3 atPosition: 3) >>> (#(#(r1c1 r1c2 r1c3)) asDataFrame)"

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"

"(#(#(1 2) #(3 4)) asDataFrame addRow: #(5 6) asDataSeries named: 3) >>> (#(#(1 2) #(3 4) #(5 6)) asDataFrame)"

"(#(#(r1c1 r1c2)) asDataFrame addRow: #(r2c1 r2c2) asDataSeries named: 2) >>> (#(#(r1c1 r1c2 ) #(r2c1 r2c2)) asDataFrame)"

self addRow: aDataSeries atPosition: self numberOfRows + 1

]

{ #category : 'adding' }

DataFrame >> addRow: aDataSeries atPosition: aNumber [

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

"(#(#(1 2) #(3 4)) asDataFrame addRow: #(5 6) asDataSeries named: 3 atPosition: 3) >>> (#(#(1 2) #(3 4) #(5 6)) asDataFrame)"

"(#(#(r1c1 r1c2)) asDataFrame addRow: #(r2c1 r2c2) asDataSeries named: 2 atPosition: 2) >>> (#(#(r1c1 r1c2 ) #(r2c1 r2c2)) asDataFrame)"

| row |

row := Array new: self columnNames size.

self columnNames withIndexDo: [ :columnName :index |

| value |

value := aDataSeries

at: columnName

ifAbsent: [ aDataSeries atIndex: index ].

row at: index put: value ].

self addRow: row 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 : 'applying' }

DataFrame >> applyElementwise: aBlock [

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

"(#(#(1 2) #(3 4)) asDataFrame applyElementwise:[ :x | x - 1 ]) >>> (#(#(0 1) #(2 3)) asDataFrame)"

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"

"(#(#(1 2) #(3 4)) asDataFrame asArray) >>> (#(#(1 2) #(3 4)))"

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame asArray) >>> (#(#(r1c1 r1c2) #(r2c1 r2c2)))"

^ self asArrayOfRows

]

{ #category : 'converting' }

DataFrame >> asArrayOfColumns [

"Converts DataFrame to the array of columns"

"(#(#(1 2) #(3 4)) asDataFrame asArrayOfColumns) >>> (#(#(1 3) #(2 4)))"

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame asArrayOfColumns) >>> (#(#(r1c1 r2c1) #(r1c2 r2c2)))"

^ contents asArrayOfColumns

]

{ #category : 'converting' }

DataFrame >> asArrayOfRows [

"Converts DataFrame to the array of rows"

"(#(#(1 2) #(3 4)) asDataFrame asArrayOfRows) >>> (#(#(1 2) #(3 4)))"

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame asArrayOfRows) >>> (#(#(r1c1 r1c2) #(r2c1 r2c2)))"

^ 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"

"(#(#(1 2) #(3 4)) asDataFrame at: 1) >>> (#(1 2) asDataSeries)"

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame at: 2) >>> (#(r2c1 r2c2) asDataSeries)"

^ self rowAt: aNumber

]

{ #category : 'accessing' }

DataFrame >> at: rowNumber at: columnNumber [

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

"(#(#(1 2) #(3 4)) asDataFrame at: 1 at:1) >>> 1"

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame at: 2 at: 1) >>> #r2c1"

^ 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"

"(#(#(1 2) #(3 4)) asDataFrame at: 1 at:1 put: 5) >>> (#(#(5 2) #(3 4)) asDataFrame)"

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame at: 2 at: 1 put: #R2C1) >>> (#(#(r1c1 r1c2) #(R2C1 r2c2)) asDataFrame)"

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"

"(#(#(1 2) #(3 4)) asDataFrame at: 1 at:1 transform: [:x| x - 1]) >>>(#(#(0 2) #(3 4)) asDataFrame)"

| 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"

"(#(#(1 2) #(3 4)) asDataFrame at: 1 transform: [:x| x - 1]) >>>(#(#(0 1) #(3 4)) asDataFrame)"

^ self rowAt: aNumber transform: aBlock

]

{ #category : 'accessing' }

DataFrame >> atAll: indexes [

"For polymorphisme with other collections."

"(#(#(1 2) #(3 4) #(5 6)) asDataFrame atAll: #(1 3)) >>> (#(#(1 2) #(5 6)) asDataFrame)"

"(#(#(r1c1 r1c2) #(r2c1 r2c2) #(r3c1 r3c2)) asDataFrame atAll: #(1 3)) >>> (#(#(r1c1 r1c2) #(r3c1 r3c2)) asDataFrame)"

^ 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"

"(#(#(10 3) #(20 1) #(30 2)) asDataFrame average) >>> (Dictionary newFrom: {(1 -> 20).(2 -> 2)})"

^ self applyToAllColumns: #average

]

{ #category : 'data-types' }

DataFrame >> calculateDataTypes [

self asArrayOfColumns doWithIndex: [ :column :i |

self dataTypes

at: (self columnNames at: i)

put: column calculateDataType ]

]

{ #category : 'comparing' }

DataFrame >> closeTo: aDataFrame [

"(#(#(1 2) #(3 4)) asDataFrame closeTo: #(#(1.0001 1.9999) #(3 4.0001)) asDataFrame ) >>> true"

"(#(#(1 2) #(3 4)) asDataFrame closeTo: #(#(1 1) #(3 4)) asDataFrame ) >>> false"

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 |

| value |

value := self at: i at: j.

(value isNumber

ifTrue: [ value closeTo: (aDataFrame at: i at: j) ]

ifFalse: [ value = (aDataFrame at: i at: j) ]) ifFalse: [

^ false ] ] ].

^ true

]

{ #category : 'comparing' }

DataFrame >> closeTo: aDataFrame precision: epsilon [

"(#(#(1 2) #(3 4)) asDataFrame closeTo: #(#(1.2 2.19) #(3 4)) asDataFrame precision: 0.2 ) >>> true"

"(#(#(1 2) #(3 4)) asDataFrame closeTo: #(#(1.21 2) #(3 4)) asDataFrame precision: 0.2 ) >>> false"

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 |

| value |

value := self at: i at: j.

(value isNumber

ifTrue: [ value closeTo: (aDataFrame at: i at: j) precision: epsilon ]

ifFalse: [ value = (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"

"(#(#(1 2) #(5 6)) asDataFrame columnAt: 2) >>> (#(2 6) asDataSeries) "

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame columnAt: 2) >>> (#(r1c2 r2c2) asDataSeries) "

^ (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"

"(#(#(1 2) #(3 4)) asDataFrame columnAt: 2 put: #(5 6)) >>> (#(#(1 5) #(3 6)) asDataFrame) "

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame columnAt: 2 put: #(R1C2 R2C2)) >>> (#(#(r1c1 R1C2) #(r2c1 R2C2)) asDataFrame) "

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"

"(#(#(1 2) #(3 4)) asDataFrame columnAt: 2 transform: [ :x | x / 2 ]) >>> (#(#(1 1) #(3 2)) asDataFrame) "

| 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"

"(#(#(1 2) #(3 4)) asDataFrame columns) >>> (#( #(1 3) #(2 4) ) collect: #asDataSeries) "

"(#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame columns) >>> (#( #(r1c1 r2c1) #(r1c2 r2c2) ) collect: #asDataSeries) "

^ (1 to: self numberOfColumns) collect: [ :j | self columnAt: j ]

]

{ #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 >> columnsAllBut: aCollectionOfColumnNames [

"Returns a <Collection> of except those present in aCollectionOfColumnNames"

^ self columns: (self columnNames copyWithoutAll: aCollectionOfColumnNames)

]

{ #category : 'accessing' }

DataFrame >> columnsAt: anArrayOfNumbers [

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

"(#(#(1 2 3) #(4 5 6)) asDataFrame columnsAt: #(1 3)) >>> (#(#(1 3) #(4 6)) asDataFrame)"

"(#(#(r1c1 r1c2 r1c3) #(r2c1 r2c2 r2c3)) asDataFrame columnsAt: #(1 3)) >>> (#(#(r1c1 r1c3) #(r2c1 r2c3)) asDataFrame)"

| 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"

"(#(#(1 2 3) #(4 5 6)) asDataFrame columnsAt: #(1 3) put: #(#(10 40) #(30 60))) >>> (#(#(10 2 30) #(40 5 60)) asDataFrame)"

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"

"(#(#(1 2 3) #(4 5 6)) asDataFrame columnsFrom: 1 to: 2) >>> (#(#(1 2) #(4 5)) asDataFrame)"

"(#(#(r1c1 r1c2 r1c3) #(r2c1 r2c2 r2c3)) asDataFrame columnsFrom: 1 to: 2) >>> (#(#(r1c1 r1c2) #(r2c1 r2c2)) asDataFrame)"

| 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"

"(#(#(1 2 3) #(4 5 6)) asDataFrame columnsFrom: 1 to: 2 put:#(#(7 8) #(9 10))) >>> (#(#(7 9 3) #(8 10 6)) asDataFrame)"

| 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."