Implementing a counter in for - for-loop

I would like to iterate over a collection and at the same time also maintain a counter ex
(for [x (range 10) y (inc 0)] [x y] )
I would like 'y' to represent the counter, so for every element the output is ( [0 0] [ 1 1] [2 2]...). How do I do that?

You can use indexed from clojure.contrib.seq. Example:
(indexed '(a b c d)) => ([0 a] [1 b] [2 c] [3 d])
You can also use map-indexed. Example:
(map-indexed vector "foobar") => ([0 \f] [1 \o] [2 \o] [3 \b] [4 \a] [5 \r])

Use map-indexed, as Simeon advices. In the for context it's convenient to use destructuring to get easy access to both the counter and the collection elements:
(for [ [y x] (map-indexed vector (range 10) ) ] [x y] )
> ([0 0] [1 1] [2 2] [3 3] [4 4] [5 5] [6 6] [7 7] [8 8] [9 9])

I figure if this question still had not been marked as "answered", there may be something else you are looking for, and perhaps it is the flexibility to define your own counter.
I agree with others that for the specific problem you outline, map-indexed is the way to go. However, if you insist on using for, I would recommend something like this:
(for [[x y] (map vector (range 10) (iterate inc 0))]
[x y])
Rafal has a very similar answer, except that the counter will always start from zero and increment by 1. In my version you could define your counter as you see fit. For example, by changing the above (iterate inc 0) to (iterate #(+ 2 %) 10), you could instead have a counter that starts at 10 and increments by 2.

(keep-indexed (fn [i el][el i]) (range 10))
or
(keep-indexed #(vec [%2 %1]) (range 10))
(keep-indexed #(identity [%2 %1]) (range 10))
;([0 0] [1 1] [2 2] [3 3] [4 4] [5 5] [6 6] [7 7] [8 8] [9 9])

Also, remember that using indexes in Clojure is generally a code smell.

Related

Update matrix in-place in Clojure

Suppose I have a Clojure matrix A as such (formatted for clarity)
[[1 4 3]
[1 7 3]
[1 8 3]]
Now suppose I want to update the first column in place, by e.g. multiplying it by a factor of two, so that the new matrix becomes
[[2 4 3]
[2 2 3]
[2 8 3]]
How would one do this in clojure? I have tried things like assoc and stuff like
(join-along 1 (* (slice A 1 0) 2) (select A [0 1 2] [2 3]))
Naturally that did not work. It would be great if there was something like assoc for matrices e.g.
(massoc A [rows] [columns] replacement-vector)
or something simple like numpy in Python:
A[:,0]*2 = [[2 4 3]
[2 2 3]
[2 8 3]]
Thanks
You should look into clojure.core/matrix and see if it supports operations like this.
Here is something that may be what you're looking for. It should be trivial to change this to assoc a new value rather than updating after applying a function.
(defn mupdate-in
"Update all `coll' rows at `column' with `f'"
[coll column f & args]
(reduce #(apply update-in %1 [%2 column] f args)
coll
(range (count coll))))
An example:
(def m [[1 4 3]
[1 7 3]
[1 8 3]])
(mupdate-in m 0 * 2)
;; [[2 4 3]
;; [2 7 3]
;; [2 8 3]]
(mupdate-in m 2 + 10)
;; [[1 4 13]
;; [1 7 13]
;; [1 8 13]]

In place matrix operations in Clojure

I asked a related question before:
Update matrix in-place in Clojure
And unfortunately, being new to Clojure, I am even more confused now.
Essentially what I would like to do, in Python syntax, is simply, with matrix A:
[[1 4 3]
[1 7 3]
[1 8 3]]
take the determinant of A, call it D, and then do
A[:,0] = A[:,0]*(D /abs(D))
upon which I would like to do
A = A*(D**(-1./A.shape[0]))
But even while perusing the functionality of core.matrix it is proving very difficult to figure out how something quite as simple is done in Clojure, even with the help of the previous question.
I have got this far [in clojure syntax]:
(join-along 1 (* (slice A 1 0) (/ (det A) (abs (det A)))) (select A [0 1 2] [1 2]))
but then then how to update in-place, without storing in variable? Currently getting error message:
Unidentified exception when trying to call procedure join-along with arguments (1 [1.0 4.0 7.0] #<NDWrapper [[2 3] [5 6] [8 9]]>)
Yet this works:
>(def t1 [[1 1] [2 2] [3 3]])
>(def t2 [[9] [9] [9]])
>(join-along 1 t2 t1)
[[9 1 1] [9 2 2] [9 3 3]]
If that could be figured out then it should simply be an issue of doing:
(* "A-updated-matrix" (pow (det A) (/ -1 (dimension-count A 0)))
Also I can imagine that the above is probably not the most efficient way of performing these matrix operations.
UPDATE:
So it appears to be a problem with the clojure accesses matrices, and outputting column vectors as row vectors.
E.g.
>(def a [[1 2 3] [4 5 6] [7 8 9]])
>(def t2 (get-column a 0)) ; Gets first column
>(join-along 1 t2 a)
Unidentified exception when trying to call procedure join-along with arguments (1 [1 4 7] [[1 2 3] [4 5 6] [7 8 9]])
However if we do
>(def i [[2] [3] [4]])
>(join-along 1 i a)
[[2 1 2 3] [3 4 5 6] [4 7 8 9]]
it works fine.

For loop in clojure

n = (count somevector)
(foo [w] ( for [i (range n)
j (range w)
:let [n (* i j)]
:while ( < i j)
]
(println n)))
When i run it.
=> (foo 10)
ClassCastException clojure.lang.LazySeq cannot be cast to clojure.lang.IFn HelloWorld.core/foo
What I am really looking to do is have a couple of nested for loops and have some ifs and else inside it do some checking.
Edit ::
As it turns out the following also causes error
(defn foo [arg]
(
for [ i (range (count vector)) ]
(
for [j arg ]
[i j]
)
) )
IllegalArgumentException Don't know how to create ISeq from: java.lang.Long clojure.lang.RT.seqFrom
Edit::
the following works
(defn foo [arg]
(def w arg)
(for [ i (range (count vector)) ]
(
for [j (range v) ]
[i j]
)
) )
Now can someone help me understand why would it not work in the first place ?
if you use :while, for-loop will return null, because first value is false, :when is better.
user=> (for [i (range 3) j (range 5)] [i j])
([0 0] [0 1] [0 2] [0 3] [0 4] [1 0] [1 1] [1 2] [1 3] [1 4] [2 0] [2 1] [2 2] [2 3] [2 4])
user=> (for [i (range 3) j (range 5) :while (< i j)] [i j])
()
user=> (for [i (range 3) j (range 5) :when (< i j)] [i j])
([0 1] [0 2] [0 3] [0 4] [1 2] [1 3] [1 4] [2 3] [2 4])
Don't know how to create ISeq from: java.lang.Long clojure.lang.RT.seqFrom
This error message states the cause of exception accurately.
I guess you passed a long value where a seq is expected.
I could reproduce it:
user> (def v [1 2 3])
#'user/v
user> (defn foo [arg]
(for [ i (range (count v)) ]
(for [j arg ]
[i j])))
#'user/foo
user> (foo (range 3))
(([0 0] [0 1] [0 2]) ([1 0] [1 1] [1 2]) ([2 0] [2 1] [2 2]))
user> (foo 3)
; Evaluation aborted.
; Don't know how to create ISeq from: java.lang.Long
; [Thrown class java.lang.IllegalArgumentException]
Your foo function works. However, the arg argument must be a seq,
because arg is binded in the nested for to j
The first thing you should know is, that clojure's for is not a for loop, it's a list comprehension.
This means, that it is used to build lists (lazy sequence, actually) with the specified properties.
Your original for looks like this:
(for [i (range n)
j (range w)
:let [n (* i j)]
:while ( < i j)]
(println n))
(I don't get a class cast exception with your original example).
What it says is: take pairs of i and j while i < j do something. The first pair of i and j is i = 0 and j = 0. Is 0 < 0? No. Stop. That is, you're constructing an empty sequence.
Now, if we change the :while with :when, it'll change the meaning to: for each pair of i and j, for which i < j, and do something with them. That is, you won't stop constructing the sequence when you encounter an i >= j, you'll just skip this pair.
The next thing to note is the println. This function prints its arguments, but always returns nil. This return value is what you'll get in the result sequence and the printing is called a side effect. Generally, you don't want side effect with lazy sequences, because they (the side effects) will happen when needed. That is, if you assign the returned sequence to some variable, none of the printlns will be called. They'll start popping up, when the sequence gets realized.
The bottom line is, don't think of for as a loop, think of it as a sequence constructor.

What is the difference between :while and :when in clojure?

I'm studying clojure but not quite clear on the difference between the :while and :when test:
=> (for [x [1 2 3] y [1 2 3] :while (= (mod x y) 0)] [x y])
([1 1] [2 1] [2 2] [3 1])
=> (for [x [1 2 3] y [1 2 3] :when (= (mod x y) 0)] [x y])
([1 1] [2 1] [2 2] [3 1] [3 3])
Can anybody help by elaborating on them ?
:when iterates over the bindings, but only evaluates the body of the loop when the condition is true. :while iterates over the bindings and evaluates the body until the condition is false:
(for [x (range 20) :when (not= x 10)] x)
; =>(0 1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19)
(for [x (range 20) :while (not= x 10)] x)
; => (0 1 2 3 4 5 6 7 8 9)
:when prevents any inner 'for' bindings or its body expression from being evaluated for that one iteration, acting like the 'filter' function.
:while halts this binding from proceeding any more, acting more like 'take-while'
Look at the last example here:
http://clojuredocs.org/clojure_core/clojure.core/for#example_913

How to generate one lazy sequence from a nested for loop in Clojure

This is a question about how to properly collect the results from a nested for loop in Clojure. Suppose you want to create a sequence of all vectors [i j] where 0<=j<i<4
The following code
(for [i (range 1 4)]
(for [j (range i)]
[i j]
)
)
produces
(([1 0]) ([2 0] [2 1]) ([3 0] [3 1] [3 2]))
but what I really want to get is
([1 0] [2 0] [2 1] [3 0] [3 1] [3 2])
What is the right way to do this?
Notice that I'm not interested in this specific sequence. My purpose here is to learn how to collect results from a nested for loop, which I need for a more complex problem.
Don't nest two loops, rather use one loop with two iterators:
(for [i (range 1 4)
j (range i)]
[i j])
Assuming you have to use nested for loops, apply concat is the preferred way to flatten a sequence by one level
=> (apply concat
(for [i (range 1 4)]
(for [j (range i)]
[i j])))
([1 0] [2 0] [2 1] [3 0] [3 1] [3 2])
#Oin's solution is always preferable, unless the inner loop depends on the outer loop.

Resources