@AviFS E.g. you could loop over something and for each one check for the existence of a file. You'd want to check each time.
There are plenty of cases where you want to run an expression each time the function is called. Another common one is using a dfn to append to a global accumulator.
A⍨ is for those cases where you truly want a constant value.
@Adám My one question is why this one-byte shortening (and admittedly optimized whatevers due to not rerunning) was added as opposed to countless other possibilities
Eg. the pair function mentioned earlier which removes need of parenthesis, thereby also shortening by one byte, making many expressions far more elegant and readable, but not actually adding any new functionality
It seems to me there are many potential operators in the category above (eg. with those 3 main traits of more elegant, slightly less code, perhaps more efficient, but no new functionality)
@AviFS It isn't just one-byte in the case where A⍨ occurs inside a longer train or before an operator. Also, you could make the same (or even a stronger) argument about N+M vs N--M. Notation as a tool of thought, I'd say.
@AviFS ⍨ is also much more clear often. Some order of implementing things must be chosen, and this managed to come before some others for Some Reasons™
@AviFS No, not really. I suggested a whole bunch of operators to add. Some were added in 18.0, others held off for later, and some not scheduled for implementation right now.
@AviFS afaik there's been discussion about whether the builtin for pair should be {⍺ ⍵} or {↑⍺ ⍵}, so that's possibly an acceptable reason for the much simpler ⍨ getting in before other things
CMC: you have n < 100 machines producing chocolate. All machines produce 100 gram chocolates except one machine that produces 101 gram choc. You want to find each one. for that you take i chocolates from machine i (from 1 to n) and add them together to S. Given S and n find the machine that produces 101 gram chocolate
Maybe I wasn't clear with what S is. S is the sum of all the weights of all the chocolates collected, knowing that I collect 1 chocolate from machine 1, 2 chocolates from machine 2, ..., n chocolates from machine n
And we know that all but one machine produce chocolate that weights 100 grams
@Adám I just read a file and got its contents in a vector but displaying it prints something which looks like a character matrix, which I think is the newlines making it print like that
but '\n'∊contents gives 0 0, which means \n isn't even an escaped newline
but I wanted to get a matrix where each row is a line of the file (don't mind extra spaces to pad short lines) and I used the first ⊆⌈ entry
About half an hour ago I started writing a function to parse the mobiles from the last problem of the APL Competition into a nicer data structure. Sure, it is recursive, but I am surprised with how "easy" it was
But this was just parsing the mobile :P I have everything left to do ;)
@AviFS no xD i understood exactly that my messages seemed out of the blue, because they were. I was wondering if you could link to the conversation you had when you wanted to expand matrices by appending rows
It's bothered me for a long time that one can't simply add another row to a vector with ⍪. I understand why, or so I think, one needs to do ⍪[.5] the first time around, and then one can continue doing ⍪ plainly. But the inconsistent format makes it hard to, for instance, extend functions which are intended to create a matrix from an empty vector on row at a time.
Too funny that that conversation starts with the exact same thing I couldn't remember how to earlier today for Cultivation!
still don't like overtaking ↑, but it's now the top slowest "thing", probably should just implement it: https://dzaima.github.io/paste/#0zZrPbhxFEMbvPMXcUTpd/7q6pcCBI29h4YAs2QlKDOLAAXGw7I1N/uAIDhzAxIJDjpFyIRzIm@yT0Luz093TYoR9q5EPM6O19qfSN99XVbPry/P15Xf/9/f6lvdv@JlnH6wvv7//zZePhvHIV5/tHR4@3p4dPzzeOxyOHo/3977@YnueT/M//XKD7/3rlvdv@JlXG@b1xQ9DOfL1MIDPRz4TRHIQkEHzlXebawhmqI8Wqb1jDYI8UXtWI9Qnzx/d/7yhBt5RgwC4KN5z3FJ78JqiEerVszk10Y564IROyAcea@095DtGqE//7qj9RE2YHBIr6kTtkxWFXDzpFAKF2rPbqJrCjho1JCu1XnXUOFEjZYVo9BCnWieKZmo99xDwlRocAauWWhOQmadxf0ZNWqizh0iWCE7UXhSMUJ@/6xQiEzWQOEkYPE3UyZup9dN5rYULtSeX2CtN…
I'm going to try to put together some rules at some point so the prototype is something well-defined (and you get an error if you try to rely on it when it isn't) rather than just being a best effort.
@Marshall with the way i do things it shouldn't be too hard (make good impls for vectors and have "something" for high ranks) :p (i don't like idea of overtaking)
@dzaima I agree, but it seems to be too useful to get rid of. Maybe there is a cleaner way, but I haven't found it. Trying to use structural Under is too awkward.
@dzaima /⁼ is just ≠¨∘⊔, and we magically have the same problem. But overtaking ⊔ makes complete sense, so it seems like at least that should be supported.
I think if Take was like Reduce, where the monadic form guesses an identity element and the dyadic form lets you specify, then it would be less objectionable. Except in this case the "monadic" form has two arguments. J uses the fit conjunction !. to get a third one in but I'm not going to do that.
note that in order to be completely logical, an overtaken ⊔s items would need to have certain shapes which is mostly impossible with a "simple" prototype system
@Marshall There could be a function that lets you specify an array's type. The concern with that is that the type shouldn't really be an element but rather a collection of properties. Maybe you could actually set the type with asserts? That's a weird side effect channel though.
@dzaima Yes, the type system should support nesting at least. Probably also other things like numbers having a fixed value or different types for different columns (hyperplanes).
I want to make a markdown to html converter so my pages can automatically evaluate and color BQN snippets, and need an example of BQN code for people who like variable names and whitespace. These two birds seem to have aligned themselves nicely...
What would be a good symbol to use for integration? Could go for ∫, but might want an additional symbol for definite integration. There are ∮∱⨑∲∳ according to wiki, but those apparently have specific meanings in different contexts (so don't want to overload/overwrite).
@Moonchild the first, fourth and fifth are for integrations along a closed line. never seen the second/third; or maybe it's just too small for me to recognize
@Moonchild definite integration is the same symbol but with numbers in sub and superscript
@Moonchild If you're integrating in 1D, I'd say just provide the indefinite form and let the user do the subtraction themselves. Although if you're intending to be a more serious CAS system then that prevents integrating functions that have singularities, so I guess you'd need both.
@RGS I have been tossing around ideas for an apl that allows for first-class ambivalent functions of any rank. But I'm not sure if it's a good idea
@Marshall I would like, ideally to make a full-on CAS. But it's not clear to me that's a practical thing to do; sagemath and octave are not on par with mathematica, and they're oss with lots of contributors
@Moonchild If you make the derived function ambivalent, you could have the left argument be the starting point, and no left argument mean any starting point as long as it's consistent.
@Moonchild Probably the number of people working on either one as a programming language rather than adding support for a particular field of mathematics is pretty small, though.
@Marshall that causes problems if you want to do multiple integrals. Plus, it would be nice for indefinite integral of a function with a singularity to fail right away
I don't have anything to say about multiple integrals, at least for now. No idea how you'd fit them into a "functional" (calling things on other things) rather than symbolic context.
@Moonchild The idea is that you can usually consistently integrate between any two singularities. So I would say it's better to pick a region and give the indefinite integral limited to that region than to just fail outright.
Btw, the antiderivative (= indefinite integral) of any function is same as the definite integral from 0 (or any well-defined starting point for that function) to x, plus C
So there's not so much reason to consider the two separately
@Bubbler If your definite integral crosses a singularity, like the poles in the tangent function, then you should get an error as this integral isn't well-defined.
@Bubbler Integral may not be computable for some functions (or the algorithm for computing it may be prohibitively complex|expensive, or not yet discovered, or just not yet implemented). But you can approximate integral over a range by sampling points. That (sampling points) is what I mean by definite integral
APL was originally envisioned as mathematical notation that could also be executed
but there are things you can express (mathematically) in the notation, that the computer implementations can't handle. Like sums of infinite sequences (cf π ≡ 4×+/1,(¯1*⍳_)÷(1+2×⍳_))
But APL syntax isn't good for manipulating functions, so you'll need a way to represent mathematical expressions as an array-like entity. So differentiation and integration can be plain functions, as is an "evaluate the expression at certain x value(s)"
Then it might work.
cf. In Mathematica, if it fails to symbolically evaluate an integral, it leaves the whole expression as-is, so that it can still be numerically "evaluated"
@Bubbler well, the idea is that, like in mathematica, integration (and other such features) would have to be interpreted in the interpreter itself. So they would have full access to the ast
