A modern programming language that makes developers happier.

kotlinlang

is there a list building method that can reference previously constructed elements of the list while building it that i'm not seeing?
Or does the collection not exist until after all its elements are determined, so that's not really possible in as a List constructor

If you start with a collection or some sort of iterable, maybe you can use `.fold`. It uses an accumulator that is passed in the lambda

yeah, i was thinking fold, but wouldn't that be crazy expensive?

oh, well i could fold into a mutable list

Or you know, sometimes a for loop is fine as well.

yeah, i just figured i could make it all pretty

i think if i did it as a sequence then i could pull elements from early parts of the list while i built it

this feels clever but obnoxious...
```        val (u: List&lt;Vector&gt;, e: List&lt;Vector&gt;) = cols.foldIndexed(ArrayList&lt;Vector&gt;(width) to ArrayList&lt;Vector&gt;(width)) { k, (u, e), a -&gt;
            u[k] = when(k) {
                0 -&gt; a
                1 -&gt; a - a * e[0] * e[0]
                else -&gt; a - e.map { a * it * it }.sum()
            }
            e[k] = u[k] / u[k].magnitude
            u to e
        }```

image.png

I think a for loop with a sum in it is way clearer.

```
val U = mutableListOf&lt;Vector&gt;()
for (a in A)
    U += (a - U.sumBy { it * a * a }).unit
```

i'll make it even better actually. i'll give you the result

```
        val e = arrayListOf&lt;Vector&gt;()
        cols.forEachIndexed { k, a -&gt;
            e[k] = when (k) {
                0 -&gt; a
                1 -&gt; a - a * e[0] * e[0]
                else -&gt; a - e.map { a * it * it }.sum()
            }
        }
```

You don't need special cases for 0 and 1 though, right?

i don't know why it pastes all skewed like that

Because you didn't select the indent of the first line.

but yeah, you're right that i don't have to, although it might speed it up a tad, and also it helps for clarity

in the algorithm, so i cut out the middleman

that's what it seems to be reading top to bottom

but this is qr decomposition, and neither q nor r are defined by u

Ah I thought you just wanted to do Gram–Schmidt.

this is the gram-schmidt qr decomp algorithm

i just posted the excerpt concerning the block of code i wrote for context