kdb+ Lists

The list is an ordered seqeuence of items and the fundamental data container and building block of kdb+. Once you master creating, updating and manipulating lists, you've mastered kdb+.

Creating Lists

The full notation for defining lists surrounds the items with parentheses and has a semi-colon between each list item. Each item placed in the list can be the same type or a different type.

q)l:(100;200;300;400) q)bl:(0b;1b;0b;1b) q)chl:("a";"b";"c";"d") q)cl:(1; `p; 200; 401) q)l 100 200 300 400 q)l:(100;200;300;400) q)l 100 200 300 400 q)bl:(0b;1b;0b;1b) q)chl:("a";"b";"c";"d") q) q)cl:(1; `p; 200; 401) q)cl 1 `p 200 401

Type of Lists

Notice the type nums for lists of all the same type are similar to what we saw for atoms ie taken from the datatype table, but are now positive. (I like to remember this by thinking that the preferred data type in the q vector language is a large list of data.) While for a mixed list that contains different types, the type number returned is 0.

q)type 2 -7h q)type (100;200;300;400) 7h q)type 1b -1h q)type (0b;1b;0b;1b) 1h q)type "a" -10h q)type ("a";"b";"c";"d") 10h q)type (1; `p; 200; 401) 0h

Create Simple Lists

Lists that contain all the same type of data are called simple lists or homogenous lists. Defining simple lists is common so there is a short notation for defining them. Normally this is no parentheses, separating each item with a space and placing the type letter at the end. For example:

100 200 300 400j (100;200;300;400) ~ 100 200 300 400j 1 2 3i fl: 1 2 3 4f el: 101.2 3.1 4.2e / no letter = defaults assumed. fl2: 1 2 3 4.

Some types use a slightly different shorthand notation.

bl:101011110000001b / boolean sl:`ppp`ooo`iii / symbol 0xAA119FF / HEX

Create Empty or Single Item Lists

Common problems to be careful of are defining single item lists and accidentally mixing types. Surrounding a single item with parentheses does not make it a list. To make a single item into a list we must use either enlist or (),x.

q)type 08:00 19:01 19:01:22 18:03:45.99 09:00 // widened to widest 19h q)type (08:00; 19:01; 19:01:22; 18:03:45.99; 09:00) // mixed 0h q)() / empty list q)type `p -11h q)type (`p) -11h q)type enlist `p // single item symbol list 11h q)type enlist `p`d // not simple list 0h q)type (),`p 11h q)type (),`p`k 11h

Common List Functions

Common operations related to lists are shown below.

• til n - generates the sequence of numbers from 0 to n-1 inclusive.
• a?b - where a and b are both atoms, chooses a random numbers between 0 and b-1 inclusive.
• count - Returns the number of items in a list

q)l:10 20 30 40 50 q)k:0.1 0.2 .3 q)count l 5 q)til 10 0 1 2 3 4 5 6 7 8 9 q)10?100 93 54 38 97 88 58 68 45 2 39 q)type l 7h q)count l,k // comma used for joining lists 8

Indexing and Assignment

Lists are ordered left to right and indexing begins at 0. A single integer references a single index alternatively supplying a list of indices retrieves the relevant list of values. Referencing a non-existant index returns a null value.

q)l:10 20 30 40 50 q)l[0] 10 q)l 1 20 q)l[3 2 1] 40 333 20 q)l 3 2 1 40 333 20 q)l[()] q)l :: // null item, empty item 10 20 333 40 50 q)l[2000] 0N q)"hello world!" [0 1 2 3 11] "hell!" q)0000101010101b [0 4 5 6] 0101b q)l[2]:333 q)l 10 20 333 40 50 q)l[2 3]:444 / assign multiple values q)l 100 200 444 444 q)l[2]:3h // error as simple list checks type 'type q)cl:(`l; 1; 2.0) q)cl[2]:3h

For assignment the colon operator is used. Similar to casting and other list functions we can assign multiple indices in one opertaion. When assigning a new value to simple lists it must be the same type otherwise an error will be thrown.

Nested Lists

In kdb+ we can have lists of lists, this is in fact quite common. These nested lists can either be defined in one statement using the longhand parentheses notation or in steps.

q)/ #### nested lists q)l:10 20 30 40 50 q)k:0.1 0.2 .3 q)nl:(l;k; `pp`qq`rr) q)nl 0 10 20 30 40 50

Once we have a nested list we can index into the list similar to before. Though in this case referring to one index will retrieve a whole list of items.

q)nl 0 2 10 20 30 40 50 `pp`qq`rr q)nl[(0;2)] 10 20 30 40 50 `pp`qq`rr q)pos:(0 1;0; 2) q)nl[pos] (10 20 30 40 50;0.1 0.2 0.3) 10 20 30 40 50 `pp`qq`rr

Indexing at Depth

Rather than indexing at the topmost level, you may want to index deeper into one of the items. (In other languages this is reffered to as two-dimensional arrays.) To index-at-depth we can either use a set of square brackets for each level or separate the indices using semi-colons:

q)/ indexing at depth q)(nl 0) 2 3033 q)nl[0][2] 3033 q)nl[0;2] 3033 q)nl[0;2]:3033 / assignment works at depth q)nl 10 20 3033 40 50 0.1 0.2 0.3 `pp`qq`rr

Eliding List Indices

Now that we know how to index-at-depth, what happens if we omit one level, yet specify the deeper one.

q)m:(10 20 30; 40 50 60; 70 80 90) q)m 10 20 30 40 50 60 70 80 90 q)m[1;] 40 50 60 q)m[;1] 20 50 80 q)al:(1 2 3.; `a`b`c; 1 2) q)dl:(1 2 3.; `a`b`c; (3.;1)) q)dl[;2] / missing fills with nulls 3f `c 0n q)m:(10 20 30; 40 50 60; 70 80 90) q)flip m 10 40 70 20 50 80 30 60 90

More List Functions

Common operations to perform on lists include:

• Find l?k - where l and k are both lists, this will return the indices of l, where each item in k can be found..
• Take A#l - where A is positive take the first A items from list l. (negative = take the last A items).
• Drop _ - where A is positive remove the first A items from list l. (negative = remove the last A items).

q)ml:`a`b`c`d`e`a`a`x`t q)ml?`b`c`t 1 2 8 q)l:10 20 30 40 50 q)3#l 10 20 30 q)-3#l 30 40 50 q)2_l 30 40 50 q)3_l 40 50 q)-3_l 10 20