@Slimey Hm, that does make more sense. On Windows, there seems to be a bug so x doesn't render (as you can see) but still contributes to the sizing. However, if you remove x it'll plot sin vs cos instead of two independent lines.
yes, i love how quick and easy it is. just wanted to see where the limits are. on my windows pc i saw the sharpplot system (if that means ]chart), but i cant find it on linux. can i load it in from a prebuilt workspace, or do you know how i can get it on linux?
You should be able to load it with )load sharpplot (but be aware that this will remove everything you've defined, so consider using a separate Dyalog instance!) and that will print instructions too. See also lessons 44 and 45 here and the full online documentation at sharpplot.com
@AlexB In normal circumstances, you shouldn't use )load (or workspaces) at all. I just abused it to make sure Slimey would see the instructions. )copy imports everything from a workspace without killing your stuff, but of course, name clashes could happen. I recommend doing (NameYouWantToImportAs←⎕NS⍬).⎕CY'WorkspaceName' and then you can refer to members of that workspace with NameYouWantToImportAs.MemberName
@Adám yes, in this context it makes sense. I have to keep thinking IBM/360. At some point, if APL is to re-gain more popularity, a few things should be updated. Perhaps keeping two UIs in parallel — legacy and 21th century — could be a sensible approach...?
There is an interesting discussion on HN right now on Smalltalk, and its image-based view of the world, which is very similar to how Dyalog's binary workspaces work (news.ycombinator.com/item?id=29890205)
@xpqz that discussion seems to echo my earlier comment to @Adám about the )load command. The integration of APL interpreter with RIDE and the environment is a point of strength but also a limitation. To reiterate on a point I made a couple of times in the last few days, JupyterLab seems to offer lots of that "integrated sandbox" advantages, with the advantage that it is disposable — you can restart afresh any time.
@AlexB Sure. Workspaces (as does, infact, spreadsheets) bundles state and functions into a blob. I like jupy notebooks, but they suffer from chaotic execution order: as you can execute cells in any order you choose, it's hard to maintain any semblence of sanity without iron discipline.
@xpqz you're right, but you can open a JupyterLab console (which guarantees execution order), or simply rerun all cells.
@xpqz ...but for programming in > small scale, the good old editor + revision ctrl + IDE is best (and Makefile, of course!). JupyterLab is good for exploration.
@AlexB I think Dyalog's heading in the right direction, though, with ]link and dyalogscript (18.2) complementing the dynamic, repl-based style. And -- yes -- workspaces have their niche, too, still.
@AlexB ]LINK is probably what you want, but it's not quite there 'out of the box' and requires a bit of fiddling to set up.
(at least on a Mac)
In some ways, LINK is more expressive than 'editor + bunch of files' -- edits made to the files directly are picked up by Dyalog, and changes made inside the session are reflected in the files.
That's cool.
Def the way to go for anything of non-trivial complexity.
@xpqz In 18.2 you can (on Windows — maybe other GUIs can set up something similar) right-click on a folder/file and select "Open with Dyalog" to get an interpreter with that folder/file linked with the root namespace. Make your changes, and close APL. No need to ever know about Link.
But can it have multiple command lines for a single application, with custom command line options?
On Windows, we'll have (subject to naming changes): "Open with Dyalog" = path/to/dyalog.exe -LOAD="%1" "Open with Dyalog (do not start)" = path/to/dyalog.exe -x -LOAD="%1"
If I remember correctly (it was many years ago I last wrote code FOR a mac), your app registers one (or more) internal URIs where you specify whatever you want to specify for the opening of a file. So it should be possible.
how would you write P(n) = n(3n - 1)/2 in an apl function, be it tacit or dfn? i did P ← .5×(¯1+3∘×)×⊢ could it be written better? im also pretty sure its better to write it out as a dfn, as that could make it a little clearer
thank you @FawnLocke. i see why you like 1-⍨ more, i think i will use that from now on, as it makes reading from right to left a little more pleasant. good to know im getting better at creating quick, tacit functions
@xpqz and @Adám, I am trying the ]LINK command. I created a namespace 'tl' and I linked it with directory 'test_link'. I edited and save a function with VI and now I want to re-sync it with the workspace, but something is wrong.
@AlexB Sorry you're having this trouble. Can you try o←⎕NS⍬ ⋄ o.source←'dir' ⋄ o ⎕SE.Link.Refresh tl
@AlexB Yes, but on non-Windows, I highly recommend upgrading to Link 3.0 which is much more polished and supports watching the dir if you install .NET Core 3.1
@AlexB Btw, for the future, press Ctrl+k before posting code, and it'll look better.
:60120404 I don't see an answer, but if you use one of my keyboard layouts (they use AltGr as APL key) then the On-Screen Keyboard does work. I can make one for your language and country if you don't like to use an English one.
o←⎕NS⍬ ⋄ o.source←'dir' ⋄ o ⎕SE.Link.Refresh tl
SYNTAX ERROR: The function does not take a left argument
o←⎕NS ⍬ ⋄ o.source←'dir' ⋄ o ⎕SE.Link.Refresh tl
∧
@AlexB Sorry, I was looking at the wrong thing. Try breaking the link and re-establishing it, first with ]break tl then ]link.create tl /path/to/tl -source=dir
@Adám yes, of course this is the first thing I tried. Breaking the link and re-creating it updates everything. But this defeats the convenience of using an external editor, if I have to always break-create for every tiny update.
It seems that the MacOS platform is behind w.r.t. Dyalog emphasis. I understand the limited resources. Most developers nowadays use either Linux or Mac, though.
Even with PowerShell and Windows Terminal, the Win platform is not as powerful and consistent as the Unix-based platforms. (At least that's my experience.)
Ah, I didn't catch that every edit caused this problem. It isn't so much a lack of emphasis as lack of in-house expertise. In any case, I recommend updating to Link 3.0 (or waiting for the release of 18.2, which comes with Link 3.0) as that has much better macOS support.
Does anyone know the exact semantics of when variables are "evaluated" (or, their value is looked up)? For example, in the sentence 1 a b 2, are a and b evaluated as a part of stranding? or before stranding happens
No, i'm just trying to implement my own APL for fun, but I am unsure when to evaluate them. When they are used in a b c←1 2 3 they are not evaluated right away, but rather stranded as a vector of names it seems. Is this only due to the ←?
@Fmbalbuena Looks like you figured it out. Congratulations!
@Richard @AlexB Now added, and that made me realise a really good reason f⍛g Y should be (f Y)g Y: That makes both monadic and dyadic equivalent to g⍨∘f⍨
One of my former colleagues once made a presentation where, in the middle, a seemingly random negative number was printed, whereto he remarked that he didn't know what that was. A while later he entered ⎕DL (delay) with a negative number (⎕DL returns the actual elapsed time) and remarked "Oh, that's what that number was!".
@Adám I've added another tilde, but I don't think I like it anymore... I have always tried to avoid rotate, thinking it's expensive on large arguments, but haven't got proves. (~⊢∊~∘≠⊢⍤/⊢)
@Adám Isn't there someway to calculate one time only? The only way I can figure out is putting it like alpha, but it wouldn't be a train and there must be something better, I think
@user1129322 Welcome the the APL Orchard. Since you're new to Stack Exchange chat, I highly recommend having a look at apl.wiki/APL_Orchard#Features. Also, feel free to introduce yourself and tell us what brings you here.
@user1129322 Since you're not a programmer yet (don't worry, we'll make you one!) have a look at apl.wiki/Learning resources#For non-programmers but be aware that we're always happy to teach and guide here, and answer any questions.
So, APL actually started as a mathematical notation rather than as a programming language (which is a bit ironic, because A.P.L. comes from "AProgramming Language). This means that many things in APL will be immediately familiar to you from school mathematics.
Absolutely. Oh, and there's nice chat bot here in the room that will evaluate APL statements that adhere to a certain format. They have to begin with `⋄ and end with `.
You probably don't know how to type ⋄ but we'll get to that. For now you can copy and paste it, or enter APl code over on tryapl.org where you don't need the ⋄
@MasterQuiz That's right. My job is to uncover that inner knowledge.
Continuing on, we can use all the 4 traditional symbol's you'd see on a calculator's buttons: ⋄ 2×3 and ⋄ 10÷4
So far, things should be clear enough. Stop me if anything is strange.
If you would like an easier way to enter the symbols that are missing from your keyboard, then visit abrudz.github.io/lb/apl and follow the instructions there.
Exactly. The rule is that if there's one number on one side (it could be the right side too) and multiple on the other, then the single one is paired up with each of the many. If both sides have multiple, they are matched up one-by-one.
If we try to match up two such lists that have differing lengths, APL will tell us that the lengths don't match: ⋄ 4 5 6 7 + 10 20 30
Very good. In general, APL uses the number 1 to mean "yes" or "true" and 0 to mean "no" or "false".
Now, APL can work with more than just number (though numbers are important). We can use texts in single quotes too, but obviously, we can't use + or > on characters. But equality works fine:
Here's a bit of a tricky thing: In your school mathematics, you probably used - to mean two different (but related) things. Can you identify what they were?
Exactly. In fact, it was a bit more than just for a negative number. It was for negation in general, e.g. -(2+3) would give -5
APL, has it much the same way, with one minor difference. The similarity is that many APL symbols (we call them primitive functions) have two (usually related) meanings. E.g. -5 negates 5 while 10-5 subtracts 5 from 10.
The difference is that for actual negative numbers, we write the minus sign raised a bit: -5 negates 5 and ¯5 is negative five.
Now you think this is a silly distinction to make, no? Surely, the two are the same!
But think about how we wrote lists of numbers above? What do you think 3 1 -4 will give? (note that most spaces don't matter in APL)
So you see there's a BIG difference between 3 1 -4 and 3 1 ¯4. The high minus allows us to write negative numbers together with other things without issues.
Let me show you something where APL extends traditional mathematics. Note that -5 is like 0-5 so it is as if there's a missing number on the left of - we always use 0 instead of the missing number.
We call that 0 a "default left argument". An "argument" isn't about a conflict. That's just what we call the inputs to our functions.
In APL, all primitive functions (and almost all functions in general) take either one or two arguments. If there's only one, the function goes on the left and the argument goes on the right. If there are two, one goes on each side.
See if you can guess what the default left argument is for ÷:
