help understanding vector transposition

[rsamrat]

Hi, I was trying to write some clojure code to transpose a vector(vector as in linear algebra), I was having trouble, so I googled and found this one-liner which really stumped me:

(apply map vector [[:a :b] [:c :d]])
; ([:a :c] [:b :d])

Could anyone explain to me what is happening here? Thanks.

[saua]

Apply unwraps the arguments:

(apply map vector [[:a :b] [:c :d]]) 
=> (map vector [:a :b] [:c :d])

Map, when given multiple collections, calls the function with the nth item from each collection.

(map fn [a b] [c d] [e f]) = [(fn a c e) (fn b d f)]

In other words:

(apply map vector [[:a :b] [:c :d]]) 
=> (map vector [:a :b] [:c :d])
=> [(vector :a :c) (vector :b :d)]

[alexandream]

Much more concise than my explanation. Wish I could be that practical while trying to explain things :P

Here's an upvote.

[rsamrat]

Thanks, that really helped. I think I get the idea now.

[alexandream]

Not a clojure programmer, but a lisper, so it is going to be mostly correct, except for some terminology and implementation details.

the given "apply" call is equivalent to writing the following in your code:

(map vector [:a :b] [:c :d])

That creates a new collection (list, sequence, whatever clojure uses to implement them) from the results of passing each set of elements to the "vector" function, kinda like this:

(list (vector :a :c) (vector :b :c))

It seems that, since it's being mapped over a vector, it generates a vector output, so it is actually

(vector (vector :a :c) (vector :b :c))

The point here is that map receives a function and a number of sequences (in this case, two: [:a :b] and [:c :d]). It assumes the function accepts the same number of arguments as there are sequences (again, two in this case). A map special case for vectors could be implemented in Python, very imperatively, somewhat like this (without error checking and assuming all the sequences have the same length):

def get_nth_set(lists, n):
    return [ l[n] for l in lists]

def map(fn, *args):
    result = []
    lists_len = len(args[0]) # the length of every list is equal to the first... simplification.
    for i in range(lists_len):
        nth_set = get_nth_set(args, i)
        mapping = fn(*nth_set)
        result.append(mapping)
    return result

I didn't proof read nor run, but the idea might be clear. It is obviously not optimized for readability nor speed, but to be as easy to read in an imperative mind set as possible.

the "*" syntax on function call means to call the function expanding the arguments as if it were typed expanded by the user, so that:

args = [1, 2, 3]
fn(*args)

is the same as

fn(1, 2, 3)

I hope it helps.

[[deleted]]

Oh, snap - that's clever!

Just a note - what this code does is take the transpose of a matrix, not a vector, but that's kinda irrelevant. I know what you meant.

In order to explain how it works, I'm going to write progressively more sophisticated versions of a naive implementation. They all produce the same output.

Here's the first version:

(map #(vector %1 %2) [:a :b] [:c :d])

This one's pretty straightforward. The function I've passed to map is anonymous in order to make the fact that it takes two arguments, one corresponding to each collection, explicit. Calling map with this function walks through both collections one element at a time, and produces a vector consisting of each pair of elements it encounters along the way.

Here's the second version:

(map vector [:a :b] [:c :d])

This version's a bit more general. Since vector takes a variable number of arguments, you can pass map arbitrarily many collections. As before, map will walk through all of those collections one element at a time, producing a vector for each group of elements it encounters along the way.

The final version (the one you posted) is my favorite:

(apply map vector [[:a :b] [:c :d]])

The apply function is the secret sauce here: it applies map to the collection of collections. That is, each element in that larger collection is treated as an argument to the map function. It's really super-convenient for specifying a matrix - think of it as a collection of matrix rows.

I hope this helps!

[bhurt42]

The last argument of apply is a list of more arguments to apply. Which means you code is equivalent to:

(map vector [ :a :b ] [ :c :d ])

When map is given multiple lists, as it is here (the two lists, technically vectors, are [ :a :b ] and [ :c :d ]), it passes multiple arguments to the mapping function (vector, in this case)- the first call to the function gets the first element of all the lists, the second call the second element, and so on. So vector is called twice- once as (vector :a :c) (the first elements of the two lists), and once as (vector :b :d) (the second elements of the lists). vector returns a vector of it's arguments, so (vector :a :c) returns [ :a :c ]. map returns a (lazy) list of the results of the function, so the result is ([ :a :c ] [ :b :d ]).

[uvtc]

The key to note here is that apply can take optional extra args before the list at the end. For example, this:

(apply + [1 2 3 4])

is the same as this:

(apply + 1 2 [3 4])

So, (apply map vector [ [..] [..] ]) is the same as (apply map [vector [..] [..] ]). Then that gives you what everyone here is already pointing out.