VincentVega has left #commonlisp [ERC (IRC client for Emacs 27.2)]
aartaka has joined #commonlisp
taiju has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
fmakuncertain has joined #commonlisp
<Spawns_Carpeting>
should my systems depend on uiop or asdf?
<Spawns_Carpeting>
or are those implicit
<hayley>
ASDF is implicit, UIOP not (in my opinion).
<yitzi>
UIOP should not be implicit, but I thought there was problems including at as a dependency.
Everything has quit [Quit: leaving]
beatastic has joined #commonlisp
<hayley>
I don't think I've had any before.
<yitzi>
Yeah, I looked through the logs I just found etimmons talking about how the fact the systems are not consistent about depending on it makes it difficult for asdf or something like that.
beatastic has left #commonlisp [#commonlisp]
<etimmons>
I'd recommend explicitly depending on UIOP if you use it.
<etimmons>
The issue yitzi is thinking of is a combo of a bug in UIOP, some decisions made by QL and ASDF folks, and devs being inconsistent in dependency declarations
fmakuncertain has quit [Ping timeout: 256 seconds]
<etimmons>
resulted in weird bugs with fasls containing a bad macro expansion
<yitzi>
So explicitly depending on UIOP fixes or at least minimizes the issure?
<etimmons>
Yep
<yitzi>
Awesome, thanks etimmons!
jpl01 has quit [Remote host closed the connection]
jstoddard has quit [Quit: ERC (IRC client for Emacs 27.2)]
<etimmons>
Although, adding that dep could break things if any of your other deps use uiop:define-package without a dependency on uiop
<etimmons>
If that happens, the best bet is probably to quickload uiop before anything else
<sm2n>
also, if you use ecl's asdf build extension, your code that uses uiop won't work unless you explicitly depend on it
s-liao has joined #commonlisp
<Spawns_Carpeting>
is there a keyword to break out of a loop macro lop
<Spawns_Carpeting>
loop*
<Xach>
Spawns_Carpeting: RETURN, sort of
<|3b|>
LOOP-FINISH ?
<rotateq>
Spawns_Carpeting: I do it most times using the NAMED keyword and then FINALLY with a RETURN-FROM and the block name
<|3b|>
not part of LOOP syntax though, if that's what you are looking for
<Xach>
more context would help
<Spawns_Carpeting>
i am attempting to write a little function that splits a string on delimiter, but I can't seem to get the loop to return correctly
<Spawns_Carpeting>
i would like to be able to break out of the code in a "do"
<Catie>
Could always THROW/CATCH
<rotateq>
okay Spawns_Carpeting, do you have it maybe on a pasteboard to look at? :)
fmakuncertain has joined #commonlisp
<rotateq>
And you can use SPLIT from the STR system if you want.
<rotateq>
Before you need something more complex achievable with CL-PPCRE or such.
<Xach>
Spawns_Carpeting: what do you have so far?
<hayley>
STR:SPLIT just calls into CL-PPCRE anyway.
<rotateq>
hayley: I just close my eyes and ears. :D lalala
<Spawns_Carpeting>
sorry my internet keeps going out, may take time for me to respond
rain3 has joined #commonlisp
amb007 has joined #commonlisp
<|3b|>
looks like that should exit the loop (possibly at the wrong time?) and you just want to return LIST from the let*
<Xach>
Spawns_Carpeting: are you interested in general feedback, beyond just the returning a value bit?
<Spawns_Carpeting>
thats a good idea, and sure Xach
<|3b|>
actually, you also want to store things into LIST before returning it
<Xach>
Spawns_Carpeting: appending to a list repeatedly can be slow. loop's COLLECT is usually a better option in that situation.
<Xach>
Spawns_Carpeting: also, (subseq string pos) is equivalent to (subseq string pos nil)
<Spawns_Carpeting>
i couldn't figure out how to get this to work with collect and still collect the last substr after search returns nil
<Spawns_Carpeting>
i will try to figure that part out
<|3b|>
test for last search returning NIL after collecting it
<|3b|>
also, i'd probably prefer () or NIL over (list)
<|3b|>
and you can let LOOP update POS for you, (loop for pos = 0 then i for i ...)
<Spawns_Carpeting>
how does "then" work?
<Spawns_Carpeting>
the lisp cookbook thing only has a tiny little section on that
<Spawns_Carpeting>
it seems to make it alternate between two values on every iteration
s-liao has quit [Ping timeout: 256 seconds]
<|3b|>
THEN is optional part of FOR = syntax. "FOR x = form1 THEN form2" sets X to result of evaluating FORM1 on first iteration and to result of evaluating FORM2 on subsequent iterations
<Spawns_Carpeting>
oh I see now
<Spawns_Carpeting>
very handy
<|3b|>
so FOR POS = 0 THEN I sets POS to 0 on the first iteration, then to the current value of I on later iterations
<|3b|>
and since it is before the FOR I ..., it sees the value of I from previous iteration
<|3b|>
i think WHILE isn't legal there, so you should put WHILE I at the end instead
<|3b|>
and if you are using SEARCH because you want to accept arbitrary strings as delimiters, you should skip by length of delimiter. if not, you might want POSITION instead
<Spawns_Carpeting>
whats the difference between position and search?
<Spawns_Carpeting>
i do want delimiters to be able to be of any length
<hayley>
POSITION finds one element, e.g. #\Space, SEARCH finds a sub-sequence, e.g. "foo"
<|3b|>
search looks for a sequence as a subsequence of another. position would find a single element in a sequence
<|3b|>
ok, sounds like you want search then
<Spawns_Carpeting>
thanks for the help btw, I added (+ i (length delimiter) as well and it seems to work great
<Spawns_Carpeting>
i realize there is uiop:string-split and ppcre split but I wanted to practice my lisp
<Spawns_Carpeting>
why is collect faster than appending to a list by the way? does it have some special optimization
<Spawns_Carpeting>
that is good to know
<|3b|>
might want to check for empty delimiter so that doesn't loop infinitely
<Xach>
Spawns_Carpeting: it generally keeps track of the tail of the list so it does not have to traverse from the beginning each time
<|3b|>
append has to duplicate all but the last list, so accumulating N items with append copies on average 1/2 N elements for every element you add, so O(n^2)
<|3b|>
collect can be expected to do something efficient internally, so should be O(1)
<|3b|>
O(N) i mean
<|3b|>
when accumulating a list like that manually, it is fairly common to accumulate with PUSH or CONS (which adds to beginning of a list without any copying), and then REVERSE or NREVERSE it at the end, which is N operations to build the list, and N to reverse it, so also O(N)
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
random-nick has quit [Ping timeout: 245 seconds]
<Spawns_Carpeting>
very interesting
akoana has joined #commonlisp
hubvu has quit [Ping timeout: 245 seconds]
<rotateq>
Spawns_Carpeting: You could also additionally consult the chapters in Practical Common Lisp and Common Lisp Recipes about LOOP. :)
s-liao has joined #commonlisp
hubvu has joined #commonlisp
jstoddard has joined #commonlisp
xaltsc has joined #commonlisp
fmakuncertain has quit [Remote host closed the connection]
fmakuncertain has joined #commonlisp
<Spawns_Carpeting>
is practical common lisp a free book rotateq
<hayley>
minion: tell Spawns_Carpeting about pcl
<minion>
Spawns_Carpeting: look at pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<Spawns_Carpeting>
there were a few books I was interested in but many of them cost a decent bit
fmakuncertain has quit [Quit: disconnected]
huckleberry has joined #commonlisp
<White_Flame>
there's a few officially free books, PAIP is another
<White_Flame>
On Lisp as well
<White_Flame>
although PCL is certainly newer than those
<huckleberry>
does anyone here have experience with (ql:quickload :cl-opengl) using 3.0+ GL? can I rely on it enough that it's shippable?
<|3b|>
should be, at least as much as anything GUI related on lisp
<beach>
Good morning everyone!
<|3b|>
(so expect apple to break things as often as possible for example)
<huckleberry>
osx graphics programming is an endless game of CVE whack-a-mole
<huckleberry>
okay, thanks, I'll try it out
<markasoftware>
mornin'
<|3b|>
note that the high-level wrapper part of cl-opengl (the GL package) has some parts that are old,poorly designed, and/or not a good fit for "modern" opengl, so you might need to use the low-level parts in %GL which are just direct bindings to the C API
<|3b|>
but as far as i know, pretty much everyone (that i've noticed on IRC) is using cl-opengl for GL
<|3b|>
how you get a window+context to use GL with has a bit less agreement :)
* |3b|
can't help with that, since the options i use (glop/glop2 and cl-glut) are probably bad choices. cl-sdl2 seems popular, and possibly some use glfw bindings
alfonsox has joined #commonlisp
notzmv has quit [Ping timeout: 268 seconds]
semz has quit [Ping timeout: 268 seconds]
szkl has quit [Quit: Connection closed for inactivity]
rain3 has quit [Ping timeout: 240 seconds]
amk has quit [Ping timeout: 256 seconds]
semz has joined #commonlisp
amk has joined #commonlisp
<huckleberry>
hurrrgh. i do not like how difficult it is to find non-trivial lisp applications that use opengl
Catie has quit [Quit: sQuit]
jealousmonk has quit [Read error: Connection reset by peer]
waleee has quit [Ping timeout: 240 seconds]
tyson2 has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 252 seconds]
jstoddard has quit [Quit: ERC (IRC client for Emacs 27.1)]
huckleberry has quit [Quit: disconnected]
Inline has joined #commonlisp
Inline has quit [Client Quit]
Inline has joined #commonlisp
Alfr is now known as Guest5028
Alfr has joined #commonlisp
Guest5028 has quit [Ping timeout: 256 seconds]
s-liao has quit [Ping timeout: 256 seconds]
zacque has joined #commonlisp
x88x88x has quit [Remote host closed the connection]
x88x88x has joined #commonlisp
notzmv has joined #commonlisp
<Spawns_Carpeting>
how can setf tell the difference between (setf 1 2) and (setf (car list) 2)
<Spawns_Carpeting>
or a better question, does (car list) return some sort of special reference where (1) evals to the number 1?
<Spawns_Carpeting>
i am curious how set works compared to the = operator in c like languages, or compared to how r and l values work
<hayley>
No reference is returned.
<hayley>
Instead (setf (car list) 2) could expand to e.g. (funcall #'(setf car) 2 list) which performs the modification. Or it could expand to some other form.
<hayley>
But generally SETF expands to a call to a function that modifies the object.
<Spawns_Carpeting>
oh thats really interesting, not what I had imagined
taiju has quit [Ping timeout: 256 seconds]
<Spawns_Carpeting>
in elisp it ends up calling a setcar or setcdr function it looks like. very interesting
Algernon69 has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.3]
Algernon69 has quit [Ping timeout: 240 seconds]
attila_lendvai has joined #commonlisp
<phoe>
hayley: well
<phoe>
I don't think that's right
<phoe>
in the general case SETF can expand to anything, as long as NEWVAL is returned
s-liao has joined #commonlisp
<phoe>
like, I don't think (setf (getf x 42) 24) is a case less general than (setf (car x) 42)
<phoe>
Spawns_Carpeting: "how can setf tell the difference between (setf 1 2) and (setf (car list) 2)" - SETF is a macro and it has access to its unevaluated arguments, and therefore it can see that it needs to set a CAR and expand accordingly
<phoe>
and for comparison with elisp, it can expand into a RPLACA call, which is CL's way of saying SETCAR
taiju has joined #commonlisp
taiju has quit [Ping timeout: 268 seconds]
pve has joined #commonlisp
akoana has quit [Quit: leaving]
perrierjouet has joined #commonlisp
perrierjouet has quit [Client Quit]
perrierjouet has joined #commonlisp
zacque has quit [Quit: Goodbye :D]
taiju has joined #commonlisp
aartaka has joined #commonlisp
gioyik has quit [Quit: WeeChat 3.3]
treflip has joined #commonlisp
attila_lendvai_ has joined #commonlisp
attila_lendvai_ has quit [Remote host closed the connection]
<pjb>
Spawns_Carpeting: (atom '1) #| --> t |# (atom '(car list)) #| --> nil |# this is how setf distinguishes them.
<pjb>
Spawns_Carpeting: then it further distinguishes (symbolp '1) #| --> nil |# (symbolp 'x) #| --> t |# between (setf 1 2) and (setf x 2).
Algernon69 has quit [Ping timeout: 245 seconds]
gaqwas has quit [Remote host closed the connection]
<beach>
Spawns_Carpeting: So places are not first-class objects in Common Lisp. Which is important when someone utters "in Common Lisp, everything is an object", and places are not objects.
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
attila_lendvai_ has quit [Quit: Leaving]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<jackdaniel>
"From what the programmer can empirically observe every CL form returns a value or signal a condition" doesn't seem to convey the message though
<beach>
Where did you quote that from?
<hayley>
A CL form can also loop indefinitely.
<jackdaniel>
beach: I've came up with that on the spot
<beach>
So no wonder it doesn't convey the message. :)
<jackdaniel>
hayley: empirically you can't observe whether it ends or not, it is indefinite observation
<jackdaniel>
beach: I'm still waiting for a better description of the phenomena often /incorrectly/ dubbed as "everything returns a value" in common lisp
nature has joined #commonlisp
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
<beach>
jackdaniel: I see. I have never seen that claim, though.
<hayley>
(values) ; You're welcome
<jackdaniel>
hayley: thank you, but that is not what I've asked for. still, your effort is much appreciated.
<jackdaniel>
beach: I recall you've criticized such claims on this or #lisp channel a few times; but recollections are often wrong
<beach>
The only one I can remember is the one I cited, i.e. "everything is an object".
<beach>
But what i can remember is of course quite limited.
aartaka has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
<edgar-rft>
I'm happy that everything in Common Lisp *has* a value, even if not necessarily a value as meant by the ANSI spec :-)
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
Alfr has quit [Killed (molybdenum.libera.chat (Nickname regained by services))]
Alfr has joined #commonlisp
s-liao has joined #commonlisp
<phoe>
everything in cl is valuable
Algernon91 has quit [Ping timeout: 250 seconds]
<hayley>
"Lisp programmers know the value of everything, and the cost of nothing."
* hayley
is trying to chase down a performance regression today. Is it one-more-re-nightmare? Can't find a commit that goes any faster. Is it SBCL? No evidence for that either. Is the desktop slower today? Hopefully not.
<hayley>
Well, the source is embarrasing. Somehow my frequency scaling governor got set to powersave, and the processor wouldn't exceed 1.5GHz, when it is supposed to run up to 3.2GHz. Now everything is back to normal.
aartaka has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
<jackdaniel>
as a side benefit the room got warmer by 2°C, I'm running cl-test-grid when it gets too cold
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
<hayley>
I survived a winter of online classes by running Minecraft with shaders on.
Algernon91 has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
cage has joined #commonlisp
Algernon666 has joined #commonlisp
Algernon91 has quit [Read error: Connection reset by peer]
dnaeon has quit [Ping timeout: 252 seconds]
Algernon666 has quit [Ping timeout: 252 seconds]
linjian has joined #commonlisp
<jackdaniel>
how would you test with parachute whether executing a form signals a condition?
<jackdaniel>
in 2am and 5am it is SIGNALS
miique has joined #commonlisp
<hayley>
FAIL
<jackdaniel>
alright, thanks
ldb has joined #commonlisp
varjag has joined #commonlisp
rito_ has joined #commonlisp
treflip has quit [Quit: bye!]
<jackdaniel>
Xach: I've moved endsec/scheduler to sharplispers/scheduler - the former organization doesn't operate for some time
aartaka has quit [Ping timeout: 240 seconds]
aartaka has joined #commonlisp
random-nick has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
cosimone has quit [Read error: Connection reset by peer]
ldb has quit [Quit: ERC (IRC client for Emacs 27.2)]
amb007 has joined #commonlisp
s-liao has quit [Quit: Client closed]
unixlisp has joined #commonlisp
tyson2 has joined #commonlisp
unixlisp has left #commonlisp [#commonlisp]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
scymtym has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
victor_ has quit [Quit: Connection closed for inactivity]
montxero has joined #commonlisp
montxero` has joined #commonlisp
rotateq has quit [Quit: ERC (IRC client for Emacs 27.2)]
montxero has quit [Quit: montxero]
dnaeon has joined #commonlisp
igemnace has quit [Quit: WeeChat 3.4]
montxero` has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
cosimone has joined #commonlisp
azimut has quit [Ping timeout: 276 seconds]
pranavats has left #commonlisp [Error from remote client]
nij- has joined #commonlisp
dnaeon has quit [Ping timeout: 245 seconds]
MetaYan has quit [Ping timeout: 265 seconds]
<nij->
CLOS is great. But is there any thing that it misses that I should pay attention to?
<jackdaniel>
modesty ,)
dnaeon has joined #commonlisp
dnaeon has joined #commonlisp
dnaeon has quit [Changing host]
s-liao has joined #commonlisp
<phoe>
nij-: CLOS doesn't miss things, CLOS makes it possible to extend itself via implementing them
<nij->
That's great :) CL doesn't miss things and allows users to extend itself. However, there was a time when amazing extensions (e.g. ASDF, QUICKLISP, CLIM.. etc) did not exist. I wonder if there are some great extensions of CLOS that haven't come to existence yet.
<_death>
nij: take a look at frame systems of the past.. in some ways they are more general than OO, e.g., they support links other than "is-a", slots can have multiple values (called facets), etc.
rain3 has joined #commonlisp
<_death>
they also tend to be more dynamic (sometimes paying the price of efficiency) and makes less of a distinction between classes and objects
<scymtym>
there is also Smalltalk-style MessageNotUnderstood which (i think) can be used, among other things, to implement generic proxy objects that respond to any message without explicit method definitions. even the concept is difficult to express in CLOS terms
s-liao has quit [Quit: Ping timeout (120 seconds)]
s-liao has joined #commonlisp
<jackdaniel>
scymtym: perhaps specializing no-applicable-method on a generic-function metaclass would be a good start?
<scymtym>
jackdaniel: to some extend, maybe. but NO-APPLICABLE-METHOD cannot specialize to the argument classes and multiple such behaviors wouldn't compose
<_death>
if you have a GF where all operations pass through you can have a "message not understood"
<scymtym>
sure, but if i understand correctly, the smalltalk version works for any message without any preparation or convention (i may be wrong)
<_death>
yeah, because the constraints they have chosen enable that
<phoe>
the issue is what is a "message" in CLOS terms
MetaYan has joined #commonlisp
<phoe>
an arbitrary GF call? if yes, who is the recipient of that message, if any?
igemnace has joined #commonlisp
<phoe>
multiple inheritance makes the "recipient" question troublesome
<scymtym>
multiple dispatch, you mean?
<jackdaniel>
hey, no-applicable-method's only method signature is specialized on T. does it mean that I can specialize it on standard-generic-function (i.e add an around method)?
<jackdaniel>
or I got it wrong and I can't specialize any standard function on the standard metaclass?
<phoe>
scymtym: welp, yes, sorry
<phoe>
jackdaniel: the latter, I think
<phoe>
I remember recently running into this issue
<phoe>
...but a custom GF would probably be good enough to implement that behavior
gaqwas has joined #commonlisp
<jackdaniel>
sure, but if you want to define "universal proxy object", you'd want it to work with functions defined by someone else too
<phoe>
because *then* you could specialize NAM and possibly defer to some kind of other dispatch mechanism that works on the types or classes of the *rest
<phoe>
oh, welp
<phoe>
that would require implementation support then - unless "someone else" also uses that custom GF
<jackdaniel>
oh well, just an exciting thought experiment
<phoe>
I don't think there's a portable way of doing what you describe :(
<jackdaniel>
well, around method and checking args for /your special proxy object/ would suffice to avoid conflicts, but nobody could add another around method :)
<phoe>
obviously, you'd need to provide some other dispatch mechanism then
<phoe>
mostly because you don't even know the length of arguments, so you can't use standard GF dispatch
<jackdaniel>
that's not a problem, you reapply all arguments as they were supplied, but with proxies replaced
attila_lendvai has quit [Ping timeout: 240 seconds]
<jackdaniel>
arity doesn't change from the original call
<phoe>
ooh, like that - yes, I see
<scymtym>
going back to original question, CLOS generic functions also cannot do "variable arity specializers". incidentally, having those would probably allow the "universal proxy" thing since you could do (defmethod n-a-m (gf (a1 proxy) &rest r)), (defmethod n-a-m (gf a1 (a2 proxy) &rest r))
<_death>
another interesting set of extensions to CLOS is that of a blackboard system like gbbopen (I mentioned this in private to nij, but may be interesting to others as well)
<nij->
scymtym: I ran into that problem two times. Recently I found some old (unfinished?) project calling itself predicate dispatch. I don't know yet if that would solve the problem.
xsperry has quit [Remote host closed the connection]
<scymtym>
nij-: if the whole object system used predicate dispatch, it would probably enable a solution. predicate dispatch as a user-defined generic function class would still require the kinds of coordination described above
azimut has joined #commonlisp
epolanski has joined #commonlisp
amb007 has quit [Ping timeout: 268 seconds]
amb007 has joined #commonlisp
azimut has quit [Ping timeout: 276 seconds]
azimut has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
varjag has quit [Read error: Connection reset by peer]
varjag has joined #commonlisp
BerntH has quit [Ping timeout: 240 seconds]
atgreen has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
xaltsc has quit [Read error: Connection reset by peer]
<beach>
Fixed. Thanks again!
<jackdaniel>
no problem
xaltsc_ has joined #commonlisp
xaltsc_ is now known as xaltsc
green__ has joined #commonlisp
atgreen has quit [Ping timeout: 240 seconds]
<jackdaniel>
it is a shame that sbcl bypass find-method by using some internal stuff
pranavats has joined #commonlisp
s-liao has quit [Quit: Client closed]
amb007 has quit [Read error: Connection reset by peer]
atgreen has joined #commonlisp
taiju has quit [Quit: Quit]
amb007 has joined #commonlisp
taiju has joined #commonlisp
green__ has quit [Ping timeout: 240 seconds]
Algernon69 has joined #commonlisp
Bike has joined #commonlisp
BerntH has joined #commonlisp
tyson2 has joined #commonlisp
<jackdaniel>
this is a fine question: assuming non-standard generic function - compute-applicable-methods-using-classes must be consistent with compute-applicable-methods (that is, when it returns its second value as true, then its first value must be equal to the result of compute-applicable-methods)
<jackdaniel>
does it mean that programmer must define methods for both
<jackdaniel>
or that the implementation can't return t as a second value of c-a-m-u-c when non-standard generic function is called? (because the programmer could have specialized only compute-applicable-methods)?
<jackdaniel>
I'll read answers (if any) later, I'm leaving the office now :)
taiju has quit [Quit: Quit]
gaqwas has quit [Ping timeout: 240 seconds]
Algernon91 has joined #commonlisp
gaqwas has joined #commonlisp
Algernon69 has quit [Ping timeout: 240 seconds]
gaqwas has quit [Remote host closed the connection]
Catie has joined #commonlisp
taiju has joined #commonlisp
Noisytoot has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Bike has quit [Quit: Ping timeout (120 seconds)]
fazz234234367 has joined #commonlisp
jealousmonk has joined #commonlisp
Bike has joined #commonlisp
rotateq has joined #commonlisp
fazz234234367 has quit [Quit: Connection closed]
<phoe>
okay, IMAGO now has a sorta decent bicubic interpolation for resizing images
<phoe>
(especially if I made some sort of stupid mistake in the algorithm and there can be more performance easily squeezed out of this thing)
Bike has quit [Quit: Connection closed]
Algernon666 has joined #commonlisp
jstoddard has joined #commonlisp
Algernon91 has quit [Ping timeout: 268 seconds]
<scymtym>
i think it would make sense (in terms of performance) to have a generic function (pixel-interpolator image method) that returns a function x y -> pixel-value which closes over the results of WITH-IMAGE-DEFINITION and the type checks. the indirection through INTERPOLATE-PIXEL-CUBIC and interpreting the channel bits also seem like possible bottlenecks
winning-luser has joined #commonlisp
winning-luser has quit [Remote host closed the connection]
<phoe>
hmmm - I assume that could work, yes
<phoe>
especially the separate interpolator
<MichaelRaskin>
I wouldn't expect there to be a good test suite for such interpolation, as people who care enough might also care enough to expect gamma…
<scymtym>
also note that alexandria defines the type specifier ALEXANDRIA:ARRAY-INDEX for, well, array indices
<phoe>
I can use that, yes
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
epolanski has quit [Quit: Connection closed for inactivity]
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Bike has joined #commonlisp
Algernon666 has quit [Read error: Connection reset by peer]
epony has quit [Ping timeout: 240 seconds]
epony has joined #commonlisp
tyson2 has joined #commonlisp
rain3 has quit [Ping timeout: 240 seconds]
notzmv has quit [Ping timeout: 240 seconds]
aartaka has quit [Ping timeout: 256 seconds]
nature has quit [Quit: leaving]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
huckleberry has joined #commonlisp
xsperry has quit []
edmrk[m] has joined #commonlisp
hayley is now known as no-defun-allowed
no-defun-allowed is now known as hayley
aartaka has joined #commonlisp
huckleberry has quit [Remote host closed the connection]
huckleberry has joined #commonlisp
huckleberry has quit [Client Quit]
huckleberry has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
aartaka has joined #commonlisp
<phoe>
Xach: where can I file bugs for vecto?
Algernon666 has joined #commonlisp
<phoe>
oh, I see, there's a github repository not linked in the main readme.
Algernon91 has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
Algernon666 has quit [Ping timeout: 250 seconds]
<scymtym>
phoe: at some point using McCLIM's raster image backend might become easier :) (but admittedly, the output quality would be worse since image patterns not sampled with bicubic interpolation at the moment)
<phoe>
scymtym: you can grab some of my bicubic code if you feel like it
<phoe>
(if it makes anything easier, that is)
<scymtym>
i have something planned for sampling pattern, so it might come in handy, thanks
amb007 has quit [Ping timeout: 240 seconds]
<phoe>
OK - feel free to use the stuff from my PR; imago uses LLGPL just like McCLIM so there shouldn't be any license incompatibility
<scymtym>
yeah
notzmv has joined #commonlisp
<phoe>
...holy cow
<phoe>
I composed my code for rotating simple bitmaps with the bicubic interpolation method from resizing
<phoe>
I got bicubic rotation for free!
* phoe
parties
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
igemnace has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 240 seconds]
Algernon666 has joined #commonlisp
Algernon91 has quit [Read error: No route to host]
Algernon91 has joined #commonlisp
Oladon has joined #commonlisp
Algernon666 has quit [Ping timeout: 240 seconds]
dnaeon has quit [Ping timeout: 250 seconds]
pve has quit [Quit: leaving]
pjb has joined #commonlisp
cosimone has quit [Ping timeout: 256 seconds]
taiju has quit [Quit: Quit]
taiju has joined #commonlisp
Xach has quit [Ping timeout: 250 seconds]
igemnace has joined #commonlisp
Jing has quit [Remote host closed the connection]
Jing has joined #commonlisp
Xach has joined #commonlisp
beach` has joined #commonlisp
Algernon91 has quit [Read error: Network is unreachable]