Recent changes to tickets

Make divide by zero evaluate to zero

2018-02-26T15:53:57.321000Z

Feature request:

Make divide by zero evaluate to zero. Currently it gives an exception, which is very sensible but not useful in a working program. This feature would remove the need for a zero check before a division.

#104 e! doesn't work on certain mixed-type arrays

2016-07-02T12:05:18.131000Z

Actually, the behaviour would be different from m!. In your example, the first permutation with e! would be [1 2 2 "A" "A" 'C 'C [] []]

#104 e! doesn't work on certain mixed-type arrays

2016-07-02T11:57:44.690000Z

I don't think the order is arbitrary at all. This behaviour would be consistent with how m! works for unsorted inputs. As for comparability, I'd just consider different types unequal, and then use the usual equality between elements of the same type (although it seems that = on two blocks always yields 0 - I'd consider blocks with equal string representation equal for this purpose, and NaNs as well). With these semantics you'd get all distinguishable permutations without discarding any indistinguishable ones.

#104 e! doesn't work on certain mixed-type arrays

2016-07-02T11:50:15.750000Z

Well, that would be possible, but it gets complicated. We'd need to get into the details of what it means to be comparable and which kinds of values are supposed to be equal, and then I'll need to do O(n^2) equality tests and define a semi-arbitrary order as you suggested. Anyway, I'll consider it.

#104 e! doesn't work on certain mixed-type arrays

2016-07-01T14:16:27.164000Z

Right, but couldn't you just give the elements comparable identities? E.g. if the input is [1 2 "A" 2 'C "A" 'C [] []] then you'd turn that into [[0 1] [1 2] [2 "A"] [1 2] [3 'C] [2 "A"] [3 'C] [4 []] [4 []]. Now the first elements are comparable and you can run your algorithm based on those, and at the end you extract the second value of each pair.

#104 e! doesn't work on certain mixed-type arrays

2016-07-01T13:53:52.953000Z

e! uses a somewhat different algorithm. It generates the permutations in lexicographic order, and does not generate duplicates (to be removed at the end). It does need the elements to be comparable. An array of ten 0's and two 1's will have exactly 66 permutations rather than 479 million out of which 66 are distinct.

#104 e! doesn't work on certain mixed-type arrays

2016-07-01T13:22:53.893000Z

Sp3000 pointed out that this is because e! does an implicit sort. That seems like an even bigger issue actually, because it means I can't reliably pick out a specific permutation if I need to (and my input is unsorted). I always assumed e! would be equivalent to (but possibly faster than) m!_&.

e! doesn't work on certain mixed-type arrays

2016-07-01T12:43:52.440000Z

e! throws an error when you mix types that aren't comparable, like:

[0 S]e!

I'm not entirely sure why that is, because m! does work, and equality can still be determined when using uncomparable types.

#61 Add a println operator

2016-05-18T15:40:20.886000Z

status: open --> fixed
assigned_to: aditsu

#103 Float parsing

2016-05-03T06:52:05.683000Z

I was thinking more of the general case, e.g. 1.23.4 for [1.23 .4] ([1.2 3.4] or [1. 23.4] are also possible, but the choice is arbitrary). Having said that this is really minor and probably not very useful, but I just thought I'd make a ticket anyway.