Essays, Posts & Presentations

Enhanced Association Tools Now Available in the Wolfram Function Repository

Bob Sandheinrich

Author

Bob Sandheinrich

Title

Enhanced Association Tools Now Available in the Wolfram Function Repository

Description

Extend the use of Association--Wolfram Language function for working with data--with tools for constructing, modifying, nesting with the original function.

Enhanced Association Tools Now Available
in the Wolfram Function Repository

March 11, 2021 — Bob Sandheinrich, Development Manager, Document & Media Systems

Association

has become one of the most commonly used symbols for developers working with any kind of data since it was introduced in Version 10 of the Wolfram Language in 2014. While there are many built-in tools for working with an Association, developers also made many tools themselves as they modernized their code. Now many of those tools have found their way into the Wolfram Function Repository. Here I’ll highlight some of my favorites and show how they compare to built-in Wolfram Language functions.

Constructing

An Association stores key-value data. There are many Wolfram Language functions for creating an Association, including

AssociationMap

AssociationThread

Counts

and

GroupBy

. The Function Repository also includes several functions for creating new associations.

You can use Association directly on a list of rules to convert it, but it only works at the top level. ToAssociations converts lists of rules deep in the expression as well:

In[]:=

Association@{"Beatles"{"Drums""Ringo","Guitar""George"}}

Out[]=

Beatles{DrumsRingo,GuitarGeorge}

In[]:=

[◼]	ToAssociations

@{"Beatles"{"Drums""Ringo","Guitar""George"}}

Out[]=

BeatlesDrumsRingo,GuitarGeorge

AssociationMap creates an Association by mapping a single function over a list, using elements of the list as keys and the outputs as values. AssociationThrough does the opposite. It maps several functions over a single value:

In[]:=

AssociationMap[Sqrt,{1,4,9,16}]

Out[]=

11,42,93,164

In[]:=

[◼]	AssociationThrough

[{Sqrt,FactorInteger,Exp},16]

Out[]=

Sqrt4,FactorInteger{{2,4}},Exp





SparseArray

is an efficient way to store sparse numeric arrays. The values are indexed numerically. SparseAssociation generalized that concept to Association so that values are indexed with keys:

In[]:=

rareanimalsightings=

[◼]	SparseAssociation

[{{"April","Black Bear"}1,{"July","Bald Eagle"}4,{"August","Bald Eagle"}1,{"November","Moose"}1},Automatic]

Out[]=

[◼]	SparseAssociation



Specified elements: 4

Dimensions: {4,3}

Default: 0



It works like an Association:

In[]:=

rareanimalsightings["April"]["Black Bear"]

Out[]=

And it gives zero as the value for keys that were not explicitly given:

In[]:=

rareanimalsightings["July"]["Black Bear"]

Out[]=

Because those values are not stored in the SparseAssociation, it is smaller when there are many default values:

In[]:=

sparseAssoc=

[◼]	SparseAssociation

[RandomInteger[1,{100,200}],{Range[100],Range[200]},0]

Out[]=

[◼]	SparseAssociation



Specified elements: 10076

Dimensions: {100,200}

Default: 0



In[]:=

ByteCount[sparseAssoc]

Out[]=

202352

In[]:=

ByteCount@Normal[sparseAssoc]

Out[]=

2555352

Modifying Associations

Associations can be modified using many standard Wolfram Language symbols like

Map

KeyMap

MapAt

and

Set

. However, the number of functions that data scientists want for manipulating their data is infinite, so they have created some of their own. Here are some that have been published in the Function Repository.

While MapAt can apply a single function to the values of specific keys in an Association, MapAtKey can apply different functions to different keys:

In[]:=

MapAt[CubeRoot,<|"Odds"{-27,-8,-1},"Evens"{16,9,4}|>,"Odds"]

Out[]=

Odds{-3,-2,-1},Evens{16,9,4}

In[]:=

[◼]

MapAtKey

[{"Odds"CubeRoot,"Evens"Sqrt},<|"Odds"{-27,-8,-1},"Evens"{16,9,4}|>]

Out[]=

Odds{-3,-2,-1},Evens{4,3,2}

KeyCombine is a combination of

Merge

and KeyMap that allows you to combine elements of an Association based on their keys:

In[]:=

data=<|

Chicago

CITY

"Windy City",

Los Angeles

CITY

"City of Angels",

New Orleans

CITY

"The Big Easy"|>;

Using KeyMap causes values to be lost:

In[]:=

KeyMap[#["TimeZone"]&,data]

Out[]=



America/Chicago

The Big Easy,

America/Los_Angeles

City of Angels

KeyCombine preserves all values in a list:

In[]:=

[◼]	KeyCombine

[#["TimeZone"]&,data]

Out[]=



America/Chicago

{Windy City,The Big Easy},

America/Los_Angeles

{City of Angels}

Manually editing the content of an Association in a notebook can be challenging. AssociationEditor provides a convenient GUI form for editing content. I modified Bob’s value in the following example and used the print button to print out the updated Association:

In[]:=

[◼]	AssociationEditor

[<|"Rick"159,"Paco"90,"Bob"90,"Michael"74|>]

Out[]=

"Rick"	\|	159	copy
"Paco"	\|	90	copy
"Bob"	\|	91	copy
"Michael"	\|	74	copy
add copy print collapse

Rick159,Paco90,Bob91,Michael74

Nested Associations

In an Association, the keys can be any expression, including lists. A side effect of that feature is that a list usually cannot be used to specify a location deep inside a nested Association. Several Function Repository functions have been published specifically to help work with nested associations.

NestedLookup treats lists as an index deep within nested associations:

In[]:=

[◼]	NestedLookup

<|"Bob"<|"Age"37,"Location"<|"City"->

Saint Louis

CITY

,"Country"->

United States

COUNTRY

|>|>|>,{"Bob","Location","City"}

Out[]=

Saint Louis

It also handles missing values at any level:

In[]:=

[◼]	NestedLookup

<|"Bob"<|"Age"37,"Location"<|"City"->

Saint Louis

CITY

,"Country"->

United States

COUNTRY

|>|>|>,{"Bob","Weight"},Missing["None of your business"]

Out[]=

Missing[None of your business]

NestedAssociate adds or modifies values deep in a nested Association:

In[]:=

[◼]	NestedAssociate

<|"Bob"<|"Age"37,"Location"<|"City"->

Saint Louis

CITY

,"Country"->

United States

COUNTRY

|>|>|>,{"Bob","Location","State"}->

Missouri, United States

ADMINISTRATIVE DIVISION



Out[]=

BobAge37,LocationCity

Saint Louis

,Country

United States

,State

Missouri, United States



NestedKeyDrop removes key-value pairs from deep in a nested Association:

In[]:=

[◼]	NestedKeyDrop

<|"Bob"<|"Age"37,"Location"<|"City"->

Saint Louis

CITY

,"Country"->

United States

COUNTRY

|>|>|>,{"Bob","Location","City"}

Out[]=

BobAge37,LocationCountry

United States



AssociationMapAt maps a function deep in a nested Association:

In[]:=

[◼]	AssociationMapAt

GeoGraphics[#["Polygon"]]&,<|"Bob"<|"Age"37,"Location"<|"City"->

Saint Louis

CITY

,"Country"->

United States

COUNTRY

|>|>|>,{"Bob","Location","City"}

Out[]=

BobAge37,LocationCity

,Country

United States



AssociationKeyFlatten converts a nested Association into a flat Association:

In[]:=

[◼]	AssociationKeyFlatten

<|"Bob"<|"Age"37,"Location"<|"City"->

Saint Louis

CITY

,"Country"->

United States

COUNTRY

|>|>|>

Out[]=

{Bob,Age}37,{Bob,Location,City}

Saint Louis

,{Bob,Location,Country}

United States



AssociationKeyDeflatten does the opposite operation*. It creates a nested association from a flat Association with lists as keys:

In[]:=

[◼]	AssociationKeyDeflatten

{"Bob","Age"}37,{"Bob","Location","City"}

Saint Louis

CITY

,{"Bob","Location","Country"}

United States

COUNTRY



Out[]=

BobAge37,LocationCity

Saint Louis

,Country

United States



* We thought the opposite of “flatten” might be “sharpen,” but we are reserving the name AssociationSharpen for this extreme data science function deployed as a resource function in my cloud account.

Modernization

The function

Counts

can be thought of as a modernization of the older function

Tally

In[]:=

Tally[{1,2,3,4,1,2,3,1,2,1}]

Out[]=

{{1,4},{2,3},{3,2},{4,1}}

In[]:=

Counts[{1,2,3,4,1,2,3,1,2,1}]

Out[]=

14,23,32,41

Similarly, other functions that predate Association have been modernized in the Function Repository. Now there are two ways to

Reap

what you

Sow

In[]:=

ReapSow

wheat

PLANT

,"Seeds";"Fuel the tractor";Sow

corn

PLANT

,"Seeds";Sow["Division","Politics"];"Sleep"

Out[]=

Sleep,

wheat

corn

,{Division}

In[]:=

[◼]	ReapAssociation

Sow

wheat

PLANT

,"Seeds";"Fuel the tractor";Sow

corn

PLANT

,"Seeds";Sow["Division","Politics"];"Sleep"

Out[]=

ResultSleep,SownSeeds

wheat

corn

,Politics{Division}

BinCounts

splits data into bins and gives you the number of items in each bin, but does not return the actual bins. BinCountAssociation uses the keys of an Association to include that information in the results:

In[]:=

BinCounts[{1,3,2,1,4,5,6,2},{0,10,1}]

Out[]=

{0,2,2,1,1,1,1,0,0,0}

In[]:=

[◼]	BinCountAssociation

[{1,3,2,1,4,5,6,2},{0,10,1}]

Out[]=

Interval[{0,1}]0,Interval[{1,2}]2,Interval[{2,3}]2,Interval[{3,4}]1,Interval[{4,5}]1,Interval[{5,6}]1,Interval[{6,7}]1,Interval[{7,8}]0,Interval[{8,9}]0,Interval[{9,10}]0

Interoperability

A final, important aspect of the Wolfram Language and the Wolfram Function Repository is that there is consistency and interoperability among all the functions. Using a function created by one developer in the Function Repository does not mean that you have to build converters or translators to use other functions in the repository or in the Wolfram Language. To illustrate, here is a big pointless blob of Association-based operations using most of the functions discussed previously (and more) together seamlessly. While the result is meaningless, the immediate compatibility warms the heart:

In[]:=

[◼]	AssociationEditor

[◼]	KeySortLike



[◼]	AssociationKeyFlatten

[◼]	AssociationMapAt



[◼]	KeyCombine

[Mod[#,3]&,#]&,

[◼]

MapAtKey

"Sown"->

[◼]	ToAssociations

,

[◼]	ReapAssociation

@TableSowi

[◼]	KeyCombine



[◼]

HashHue

[◼]	BinCountAssociation

Values@

[◼]	AssociationThrough

[{Sqrt,Exp},i],"Factors",{i,1,40},{"Sown","Factors"},{{"Sown","Factors",1},"Result"}

Out[]=

{"Sown","Factors",1}	\|	copy
{"Result"}	\|	copy
{"Sown","Factors",2}	\|	copy
{"Sown","Factors",0}	\|	copy
add copy print collapse

The functions mentioned here are only some of the Association tools in the Function Repository, which in turn are only a small piece of the consistently growing collection in the full repository. Every week, new functions are added that both expand the Wolfram Language and fill in some of its gaps. There is no longer any need to wait for Wolfram Language version releases to see the latest and greatest new functions: you can get them any time you want right here.

Explore more user contributions like the functions mentioned here or submit your own computational creations at the Wolfram Function Repository.

Cite this as: Bob Sandheinrich, "Enhanced Association Tools Now Available in the Wolfram Function Repository" from the Notebook Archive (2021), https://notebookarchive.org/2021-03-4nkxnxp