mwnaylor` has quit [Read error: Connection reset by peer]
kchanqvq has quit [Ping timeout: 252 seconds]
admich1 has quit [Ping timeout: 245 seconds]
admich1 has joined #commonlisp
mwnaylor` has joined #commonlisp
rkazak has quit [Ping timeout: 265 seconds]
rgherdt has joined #commonlisp
istewart has quit [Quit: Konversation terminated!]
Oladon has quit [Quit: Leaving.]
ingeniot has quit [Ping timeout: 260 seconds]
kchanqvq has joined #commonlisp
mwnaylor` has quit [Ping timeout: 276 seconds]
<kchanqvq>
beach: hmm I looked at those before but I didn't recall anything about O(log n) space delete-duplicates. The 10th is "First-class Global Environments in Common Lisp", is that it?
mwnaylor` has joined #commonlisp
<beach>
No.
<beach>
Processing list element in reverse order, or something like that.
<kchanqvq>
ah find it, thanks!
<beach>
Sure.
<beach>
I put the link to all the documents in case someone is interested.
<jackdaniel>
kchanqvq: it goes like this: you take the middle of the list, then you take the middle of the reminder recursively until you have the end of the list
<jackdaniel>
beach: did I get it right?
<beach>
Sounds right, yes.
<beach>
My memory is not great, and yours is likely much better. But it sounds plausible.
<beach>
So the recursions are by splitting the list in two halves.
<kchanqvq>
very interesting idea!
<kchanqvq>
I guess this adds a log(n) time factor, though?
<beach>
I don't remember.
<beach>
I am thinking not, but I may be wrong.
mgl has joined #commonlisp
pve has joined #commonlisp
khrbtxyz has quit [Server closed connection]
khrbtxyz has joined #commonlisp
rkazak has joined #commonlisp
fosskers has quit [Remote host closed the connection]
younder has quit [Remote host closed the connection]
younder has joined #commonlisp
varjag has joined #commonlisp
rkazak has quit [Ping timeout: 245 seconds]
<jackdaniel>
in worst case scenario: N (list length) + 1 + 2 + 4 + 8 ... + N/2, so sounds about right
mwnaylor` has quit [Ping timeout: 252 seconds]
<beach>
Thanks.
mwnaylor` has joined #commonlisp
<jackdaniel>
it is the first time I'm writing an elisp program -- lime.el will allow for connecting slime with a lisp running in a browser using websockets
<jackdaniel>
I have to say that elisp is not half bad -- not as foreign as scheme; and emacs documentation is good
<beach>
Great!
<aeth>
elisp just feels like old/outdated Common Lisp (probably because it was intentionally archaic in design)
<jackdaniel>
it will work like: SLIME <-> LIME <-websocket-> WANK <-> SWANK
<jackdaniel>
if I remember correctly elisp descends from LISP, so in other words, they have common ancestor
<aeth>
jackdaniel: yes, but Scheme was "let's try new things" while elisp was "let's stick to old[er than Common Lisp] things"
<aeth>
although I guess that makes it closer to CL
rkazak has joined #commonlisp
_whitelogger has joined #commonlisp
rkazak has quit [Ping timeout: 276 seconds]
jistr has quit [Remote host closed the connection]
mwnaylor` has quit [Ping timeout: 272 seconds]
lcn_ has joined #commonlisp
jistr has joined #commonlisp
younder has quit [Remote host closed the connection]
mwnaylor` has joined #commonlisp
<edgar-rft>
Elisp originally was a heavily simplified clone of Maclisp, but that was long ago
<ixelp>
The Revised Maclisp Manual (The Pitmanual)
<aeth>
it's like the hyperspec except for Maclisp. I don't think Interlisp has something like that, but I'm not sure? Lisp Machine Lisp just has PDFs
<jackdaniel>
genera used concordia for documentation
X-Scale has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
mwnaylor` has quit [Ping timeout: 276 seconds]
mwnaylor` has joined #commonlisp
treflip has quit [Ping timeout: 248 seconds]
younder has quit [Remote host closed the connection]
younder has joined #commonlisp
TactfulCitrus has quit [Ping timeout: 248 seconds]
Anonim has joined #commonlisp
Anonim has quit [Read error: Connection reset by peer]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 272 seconds]
mwnaylor` has quit [Ping timeout: 276 seconds]
mwnaylor` has joined #commonlisp
_Posterdati_ has joined #commonlisp
_Posterdati_ has quit [Client Quit]
treflip has joined #commonlisp
mwnaylor` has quit [Ping timeout: 260 seconds]
treflip has quit [Read error: Connection reset by peer]
mwnaylor` has joined #commonlisp
treflip has joined #commonlisp
rgherdt has quit [Remote host closed the connection]
rkazak has joined #commonlisp
rgherdt has joined #commonlisp
ciuhh has joined #commonlisp
kchanqvq has quit [Quit: Client closed]
rkazak has quit [Ping timeout: 248 seconds]
X-Scale has quit [Ping timeout: 260 seconds]
lusciouslover has quit [Quit: \]
<nil>
elisp has very slowly been getting more CL features over the last few decades. Some, like keyword arguments, probably can't be added while RMS is still breathing, due to his disdain for them. I guess eventually it'll have most of the features of CL.
rkazak has joined #commonlisp
<nil>
Concordia is really just a very souped-up Emacs (or rather Zmacs) mode, which turned out to be better for document creation, in my opinion, than anything since, including TeX and MS Word, although Interleaf (also written in Lisp) was supposedly good, but I don't know since I only used it for a few days, and it seemed less Emacs-y.
random-nick has joined #commonlisp
rkazak has quit [Ping timeout: 276 seconds]
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life has joined #commonlisp
rkazak has joined #commonlisp
ciuhh has quit [Ping timeout: 272 seconds]
rkazak has quit [Ping timeout: 265 seconds]
X-Scale has joined #commonlisp
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 276 seconds]
Lycurgus has joined #commonlisp
euandreh has joined #commonlisp
Lycurgus has quit [Quit: irc.renjuan.org (juan@acm.org)]
rkazak has joined #commonlisp
<pl>
isn't the case with Concordia more like ZMacs got separated into various component pieces and some of them got reused?
<pl>
haven't disassembled it though
<nil>
that's the best way to implement a CL Emacs regardless of Concordia
<pl>
DW/CLIM streams/sheets etc. are pretty nice way to handle such applications
jonatack has joined #commonlisp
cercopith has quit [Remote host closed the connection]
rkazak has quit [Ping timeout: 252 seconds]
ingeniot has joined #commonlisp
mwnaylor` is now known as mwnaylor
paulapatience has quit [Server closed connection]
paulapatience has joined #commonlisp
attila_lendvai has joined #commonlisp
<attila_lendvai>
which PEG parser lib would you recommend for a simple experiment? i'm planning to generate an assembler from the LLVM tablegen description
<beach>
scymtym might be around, and he would know whether it is any good.
<beach>
Then again, he might be on vacation.
rkazak has joined #commonlisp
<attila_lendvai>
i'm not overly excited about generating an assembler, but the prospects for Maru is pretty exciting (eliminate one of the last two external dependencies). then rewrite it's makefile in maru, and it becomes completely standalone (directly on top of the linux kernel)
<attila_lendvai>
beach, you're working on the CL compiler that clasp uses, right? how do you generate machine code?
<beach>
attila_lendvai: No that's bike's department.
X-Scale has quit [Ping timeout: 260 seconds]
<attila_lendvai>
oh, sorry. it's been a while i was last hacking CL...
<beach>
I see. Well, the two (SICL and Clasp compilers) used to be more connected than they now are.
<attila_lendvai>
cleavir probably generates LLVM IR, so there's no x86 assembler there
<beach>
Claevir (v2, what Clasp uses) uses LLVM, yes. And it is very slow. Not the generated code, but the code that produces the generated code.
admich1 has quit [Ping timeout: 276 seconds]
<beach>
Cluster is an x86 "assembler" if you need one, but it is very likely incomplete. Also phantomics has an assembler.
<scymtym>
attila_lendvai: esrap is fine for most grammars. left-recursion is handled but can be tricky and due to the packrat nature. alternatives are ordered (as opposed to proper backtracking in most parsers). modularity is not great as rules are named by symbols with no protection from overwriting other libraries' rules
X-Scale has joined #commonlisp
<scymtym>
*tricky. and due the packrat nature, alternatives
<ixelp>
GitHub - robert-strandh/Cluster: Assembler with input in the form of standard instances
<phantomics>
This is my assembler:https://github.com/phantomics/specops, but X86 is still a WIP. I've been recently looking into available X86 instruction specs so I don't have to transcribe instruction code by hand
<ixelp>
GitHub - phantomics/specops: Assembler framework for Common Lisp.
jonlevin has quit [Server closed connection]
jonlevin has joined #commonlisp
<attila_lendvai>
my primary goal is to write the tblgen -> asm generator in CL (comfortable), and then port to maru (end goal). but then why not also leave a useful assembler for CL posterity...
* attila_lendvai
looks into phantomics' code
rkazak has quit [Ping timeout: 248 seconds]
<attila_lendvai>
phantomics, do you think it would make sense for me to do this experiment as a PR for specops?
<attila_lendvai>
phantomics, note that the PEG parsing stuff for tblgen could be added in a way that it only needs to be run by the devs and the result checked into the repo
<phantomics>
That could work, SpecOps is designed to be a framework you can use to build assemblers for any architecture. It has modules for several different systems currently, you can look at them to see how I express their instructions
* attila_lendvai
is not sure about licencing though
<bike>
llvm does optimization and such, so using it as just an assembler is obviously pretty overkill
<bike>
unrelated question: what is the use of the epsilon constants? as defined they're kind of confusing, e.g. (+ 1f0 single-float-epsilon) = (+ 1f0 (* 2 single-float-epsilon)) with ieee floats
<bike>
i looked around github and see a few uses of it as the unit of least precision, which it is not
<attila_lendvai>
bike, just an assert: they have x86.tb and various other descriptions for their targets. i'm not planning to use LLVM IR as an assembler (sidenote: maru also has an LLVM backend to bootstrap through besides the x86 one)
<bike>
sure
mwnaylor has quit [Ping timeout: 260 seconds]
mwnaylor has joined #commonlisp
<beach>
bike: Where do you see that (+ 1f0 single-float-epsilon) = (+ 1f0 (* 2 single-float-epsilon))?
<bike>
beach: sbcl, clasp, ecl (the latter two of which define the epsilon in terms of the CLHS definition quite directly)
<bike>
i think it's actually required if the implementation is using ieee floats
admich1 has joined #commonlisp
<bike>
single-float-epsilon will be defined as a little more than half the difference between 1f0 and the next representable float, so (+ 1f0 single-float-epsilon) rounds up to the next representable float, and (+ 1f0 (* 2 single-float-epsilon)) rounds down to that same float
fgarcia has joined #commonlisp
<bike>
i suppose that also means the CLHS definition is dependent on the rounding mode, but of course the lisp standard doesn't define anything about rounding modes
<attila_lendvai>
phantomics, your specops lib seems to provide a more sophisticated API than i'm planning to use. i'll probably write up some independent stuff and keep in mind that it should be easily portable to specops. once i can generate anything useful from tblgen then we'll see how to proceed...
<beach>
bike: But the definition in the standard doesn't mention (* 2 single-float-epsilon) as far as I can see.
<ixelp>
specops/specops.lisp at master · phantomics/specops
<bike>
beach: No, it doesn't. I'm saying this behavior is implied by the CLHS definition for the reason I just gave
<beach>
I see.
acdw has left #commonlisp [smell ya later]
<attila_lendvai>
phantomics, thanks! busy making notes...
<phantomics>
This is an expedient way to compose and decompose bitfields, the join-spec function in the same file may also be handy, it's the basic tool for gluing instructions together into binary vectors
<phantomics>
I'd be interested to see what you come up with
<bike>
The definition is that the epsilon is the smallest number that can be added to 1 to get a different float. That probably won't (definitely won't, in IEEE) be the difference between 1 and the next representable float, because of rounding.
<beach>
Yes, I see.
<bike>
i forgot i had clisp installed. they're equal there as well
randm has quit [Remote host closed the connection]
randm has joined #commonlisp
<attila_lendvai>
phantomics, my goal is to come up with enough to be able to generate simple code, but keep speed in mind. i'm aiming for depth results and probably won't finish the breadth work unless it comes easy
<bike>
here is an example from, coincidentally, phanatomics: https://github.com/phantomics/april/blob/master/functions.lisp#L16 and while I don't know exactly what they're going for, if what they want is a random number that is above zero exclusive, they're not going as low as they could because (/ double-float-epsilon 2) is distinct from zero but obviously less than the epsilon
<ixelp>
april/functions.lisp at master · phantomics/april
<bike>
here the issue (such as it is) is that double-float-epsilon is the minimum around 1, not around 0
<bike>
Obviously extremely minor, but it means I'm lacking an understanding of actual uses of these constants
<ixelp>
llvm-project/llvm/lib/Target/X86/X86.td at main · llvm/llvm-project
<bike>
actually i guess in this case least-positive-double-float is available
mwnaylor has joined #commonlisp
<bike>
the (- 1d0 (* 2 double-float-epsilon)) is probably also off, both in that the negative-epsilon is not the same as the epsilon, and because I think this is trying to get the second next representable double towards 0, which is not what it will be
<bike>
Floats are so finicky.
<phantomics>
attila_lendvai, haven't looked at it, good to see a quantification of x86 version features
<attila_lendvai>
phantomics, too bad. i was hoping for your better informed opinion whether i'm walking into a deep forest... :)
<phantomics>
So that tblgen is what they needed to generate C++ code, lacking the use of macros
<beach>
bike: Indeed. Could it be that the creators of the standard missed something?
<attila_lendvai>
phantomics, i don't think the presence or the lack of macros changes much about the tblgen descriptions. my understanding is that it's a DSL, regardless of how it'll be turned into an API. now, my question/doubt is: how much negative influence did it receive due to the fact that the whole thing is implemented on top of C++... but i guess i'll see
<bike>
beach: the definition is specific and unambiguous, so they probably had _something_ in mind? I just don't know what. I don't deal with floats enough to have any idea of what these would be used for.
<phantomics>
My point is that having macros makes it far easier to implement what tblgen does
<beach>
bike: Yes, I agree.
rkazak has joined #commonlisp
X-Scale has quit [Ping timeout: 260 seconds]
<phantomics>
bike: so double-float-epsilon can be halved in that situation and be a distinct number?
<bike>
phantomics: double-float-epsilon is around 1d-16, whereas least-positive-double-float is around 5d-324, so you can do a lot more than half it
<phantomics>
Ok, neat
<bike>
or least-positive-normalized-double-float is about 2d-308 if you don't like subnormals
<phantomics>
I could use those to define the random range then
rkazak has quit [Ping timeout: 276 seconds]
<bike>
they wouldn't get you the upper bound on the range though, since (= 1d0 (- 1d0 least-positive[-normalized]-double-float))
<bike>
i don't think there's any easy way to get the second next representable float in any direction, or at least not as easy as subtraction of these constants
<bike>
the conceptual problem is that floats aren't a linear thing. the distance between representable floats increases as their magnitude increases. so (/= 0d0 (+ 0d0 least-positive-double-float)) but (= 1d0 (+ 1d0 least-positive-double-float))
<bike>
sorry if this sounds too obvious, i'm working through it myself
varjag has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.3)]
<beach>
bike: Can other epsilons somehow be derived from the standard ones?
rkazak has joined #commonlisp
<beach>
Oops. Dinner is served. I'll be back tomorrow.
bpanthi977 has joined #commonlisp
Lycurgus has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
<|3b|>
i think the general idea of the epsilon is that you can multiply it by a value to get an idea of the granularity of floats around that value. so for example if you want to determine if 2 values are "close enough", you can subtract and then compare to epsilon*larger-value*N where N is amount of closeness appropriate for the math leading to the values
Guest68 has joined #commonlisp
* |3b|
also expected them to be "difference between 1 and next representable float" though, and missed the wording in the spec requiring a smaller value
Guest97 has joined #commonlisp
<|3b|>
spec wording seems like it might not be good in practice though, something that rounds correctly for 1 might not round correctly when multiplied by other values
Guest68 has quit [Ping timeout: 252 seconds]
varjag has quit [Ping timeout: 245 seconds]
admich1 has quit [Ping timeout: 260 seconds]
admich1 has joined #commonlisp
phil_bb has quit [Ping timeout: 276 seconds]
Lycurgus has quit [Quit: irc.renjuan.org (juan@acm.org)]
phil_bb has joined #commonlisp
<bike>
|3b|: yeah, the scaling is slightly off, since the epsilon is _slightly greater than_ half the ULP. (* 2 single-float-epsilon) is slightly more than the "epsilon" for 2f0, as in there is an E s.t. (> (+ 2f0 (* 2 E)) 2f0) and (> (* 2 single-float-epsilon) E)
rkazak has joined #commonlisp
admich1 has quit [Ping timeout: 260 seconds]
admich1 has joined #commonlisp
joast has quit [Quit: Leaving.]
X-Scale has joined #commonlisp
rkazak has quit [Ping timeout: 276 seconds]
rkazak has joined #commonlisp
joast has joined #commonlisp
ingeniot has joined #commonlisp
treflip has quit [Ping timeout: 240 seconds]
ingeniot has quit [Ping timeout: 248 seconds]
wohonajax has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
Oladon has joined #commonlisp
mgl has quit []
rkazak has joined #commonlisp
Lycurgus has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
<mesaoptimizer>
do people use CMUCL these days? I first heard of it in the SLY manual, listed as better supported than even SBCL. I looked at the CMUCL page and it looks very surprising to me
<Lycurgus>
i did until c. '08/9, with cl-http
<Lycurgus>
they both fell off
<mesaoptimizer>
really? interesting. The last major release was in 2023
<Lycurgus>
but yeah ppl do, i still get the list email at the start of every month
<Lycurgus>
it's immortalized by cultural factors, its institutional setting
<Lycurgus>
sbcl is basically community cmucl
<mesaoptimizer>
huh I see
<Lycurgus>
cum 15+ y dev divergence
<Lycurgus>
they (cmucl and sbcl) still interact
<mesaoptimizer>
all right then. I was a bit impressed by reading that it also implements its own emacs-like editor in common lisp, and has graphical debugging capabilities, but if it seems entirely unused in the broad community, then there's no need for me to look deeper
<Lycurgus>
since both are still live
<Lycurgus>
i am mum on those things, u'll find out soon enuf
<Lycurgus>
(editor and lisp graphics)
apa_c has joined #commonlisp
<mesaoptimizer>
nice
rkazak has joined #commonlisp
RavenJoad has joined #commonlisp
<RavenJoad>
Real quick, how can I force implementations to defer the execution of a form to runtime? I figure this is a case for (eval-when (...) ...)?
<|3b|>
depends on your definition of "runtime", but probably "put it in a function and call the function when you want it to run"
<|3b|>
possibly with some implementation specifics for calling it when an image loads or something
rkazak has quit [Ping timeout: 244 seconds]
<|3b|>
or maybe with LOAD-TIME-VALUE
<RavenJoad>
I want to do this for a unit test. I have an object where I deliberately have a type-error in a slot. I think this is being caught at compile-time (when the test is compiled too), which happens before the test runs.
<|3b|>
calling EVAL or COMPILE manually can be useful for that sort of testing, if the test lib doesn't already let you check for compile-time errors
<RavenJoad>
I haven't checked to see if/how lisp-unit2 handles potential compile-time errors.
Lycurgus has quit [Quit: irc.renjuan.org (juan@acm.org)]
rkazak has joined #commonlisp
gorignak has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
random-nick has quit [Ping timeout: 240 seconds]
RavenJoad has quit [Ping timeout: 240 seconds]
apa_c has quit [Ping timeout: 265 seconds]
rkazak has joined #commonlisp
varjag has joined #commonlisp
dino_tutter has quit [Server closed connection]
dino_tutter has joined #commonlisp
mgl has joined #commonlisp
random-nick has joined #commonlisp
rkazak has quit [Ping timeout: 265 seconds]
admich1 has quit [Ping timeout: 248 seconds]
rkazak has joined #commonlisp
admich1 has joined #commonlisp
rkazak has quit [Ping timeout: 252 seconds]
bigbooko1bug has joined #commonlisp
bigbooko1bug has quit [Client Quit]
apa_c has joined #commonlisp
mgl has quit []
admich1 has quit [Ping timeout: 276 seconds]
admich1 has joined #commonlisp
rkazak has joined #commonlisp
admich1 has quit [Read error: Connection reset by peer]
admich1 has joined #commonlisp
rkazak has quit [Ping timeout: 272 seconds]
Guest97 has quit [Ping timeout: 252 seconds]
admich1 has quit [Ping timeout: 248 seconds]
admich1 has joined #commonlisp
apa_c has quit [Ping timeout: 252 seconds]
rkazak has joined #commonlisp
pve has quit [Quit: leaving]
rkazak has quit [Ping timeout: 265 seconds]
shawnw_ has quit [Ping timeout: 248 seconds]
kchanqvq has joined #commonlisp
Oladon has quit [Quit: Leaving.]
rkazak has joined #commonlisp
varjag has quit [Ping timeout: 240 seconds]
rkazak has quit [Ping timeout: 245 seconds]
rgherdt has quit [Remote host closed the connection]