00:00:00 --- log: started forth/14.02.08
01:36:33 --- join: true-grue (~quassel@95-25-39-48.broadband.corbina.ru) joined #forth
01:50:29 --- quit: drobban_ (Changing host)
01:50:29 --- join: drobban_ (~drobban@unaffiliated/robban-/x-2743946) joined #forth
02:13:11 --- quit: mnemnion (Remote host closed the connection)
02:22:23 --- join: fantazo (~fantazo@213.129.230.10) joined #forth
02:35:04 --- quit: kludge` (Ping timeout: 246 seconds)
02:40:23 --- join: kludge` (~comet@unaffiliated/espiral) joined #forth
02:45:42 --- quit: ASau (Remote host closed the connection)
02:48:06 --- join: ASau (~user@p54AFE827.dip0.t-ipconnect.de) joined #forth
02:52:59 --- join: mnemnion (~mnemnion@c-98-210-219-91.hsd1.ca.comcast.net) joined #forth
03:22:12 --- join: tangentstorm (~michal@108.218.151.22) joined #forth
03:56:43 --- join: pvt_petey (~pvt_petey@82-69-79-20.dsl.in-addr.zen.co.uk) joined #forth
05:05:33 --- quit: mnemnion (Remote host closed the connection)
05:19:07 <yunfan_> kulp: i checked that NeWS , and yes , it was a bit like my thought
07:21:55 --- join: nighty-_ (~nighty@CPE0026f3096ae8-CM0026f3096ae5.cpe.net.cable.rogers.com) joined #forth
07:30:02 --- join: kumul (~mool@adsl-207-204-134-128.prtc.net) joined #forth
08:52:00 --- quit: pvt_petey (Quit: Computer has gone to sleep.)
09:41:38 --- join: Zarutian (~zarutian@194-144-84-110.du.xdsl.is) joined #forth
10:21:02 --- join: klltkr (~klltkr@unaffiliated/klltkr) joined #forth
10:22:33 --- join: mnemnion (~mnemnion@c-98-210-219-91.hsd1.ca.comcast.net) joined #forth
10:25:50 --- quit: nighty-_ (Remote host closed the connection)
10:27:56 <Zarutian> kumool: I thought Mako was a Virtual Machine specification
10:28:50 --- join: dys (~user@2a01:1e8:e100:8296:21a:4dff:fe4e:273a) joined #forth
10:33:32 --- quit: dys (Read error: Connection reset by peer)
10:51:31 --- join: mnemnion_ (~mnemnion@c-98-210-219-91.hsd1.ca.comcast.net) joined #forth
10:53:09 --- quit: mnemnion (Ping timeout: 260 seconds)
10:58:06 --- join: dys (~user@2a01:1e8:e100:8296:21a:4dff:fe4e:273a) joined #forth
11:06:54 <tangentstorm> i missed the first part, but mako also has an implementation in java, Zarutian 
12:00:13 --- join: impomatic_ (~chatzilla@79.251.125.91.dyn.plus.net) joined #forth
12:01:03 --- join: pvt_petey (~pvt_petey@82-69-79-20.dsl.in-addr.zen.co.uk) joined #forth
12:19:03 --- part: impomatic_ left #forth
12:42:50 --- quit: true-grue (Read error: Connection reset by peer)
13:35:45 --- quit: fantazo (Quit: Verlassend)
15:20:56 <kumul> https://github.com/JohnEarnest/Mako
15:30:43 <Zarutian> yunfan_: basicly the opencroquet model of simplified teatime? (all clients interested keep a replica of the forh vm running and just send their inputs  to the server which echos them back to everyone with an replica)
15:39:41 <gordonjcp> multiplayer Forth?
15:40:19 <gordonjcp> you could do that
15:40:30 <gordonjcp> make a cross between Forth and the card game Uno
15:40:50 <gordonjcp> to win you've got to be the one that pops the last item off the stack and no more
16:01:34 --- join: ASau` (~user@p54AFFB99.dip0.t-ipconnect.de) joined #forth
16:05:05 --- quit: ASau (Ping timeout: 260 seconds)
16:10:38 --- quit: karswell (Read error: Connection reset by peer)
16:22:28 <Zarutian> gordonjcp: nice idea for a board/card-game but probably not what I or yunfan_ meant
16:30:36 <tangentstorm> https://github.com/JohnEarnest/VectorLand 
16:30:38 <tangentstorm> ,
16:30:39 --- join: karswell (~user@84.93.180.60) joined #forth
16:30:43 <tangentstorm> ^ multiplayer forth?
16:30:50 <tangentstorm> oh it's java
16:31:16 * tangentstorm just assumed he'd use mako :)
17:28:51 --- join: drobban (~drobban@78-73-61-250-no187.tbcn.telia.com) joined #forth
17:28:55 --- join: nys (~nys@blk-142-60-139.eastlink.ca) joined #forth
17:29:22 <nys> hello there
17:29:45 <nys> how would one go about defining a word to test whether two strings are equal?
17:31:30 <tangentstorm> well... first, that word probably already exists :)
17:31:35 <nys> i tried a while ago but i couldn't reduce it to fit my criteria of complexity
17:31:41 <nys> of simplicity i mean
17:31:52 <tangentstorm> well what did you try?
17:32:13 <nys> i don't remember but it spanned three lines and used the return stack so >_>
17:33:55 --- quit: drobban_ (*.net *.split)
17:33:55 --- quit: Ethical (*.net *.split)
17:34:56 <tangentstorm> hrm
17:34:58 <nys> i'll give it another go
17:35:43 <Zarutian> hmm.. two counted strings or null terminated strings?
17:36:09 <Zarutian> I think there such word used in the find word iirc
17:36:25 <Zarutian> (at least in eForth)
17:36:31 <tangentstorm> COMPARE is the standard word
17:37:19 <tangentstorm> retro has a word to exit a function early if tos is 0:  0;;  how would i do that in forth?
17:38:21 <nys> two addresses and a length
17:40:20 --- join: Ethical (~sam@139.216.253.31) joined #forth
17:40:50 <nys> alright here's one with a 19 word body: : str= 0 do 2dup c@ swap c@ = if 2drop 0 unloop exit then 1+ swap 1+ loop 2drop -1 ;
17:41:04 <tangentstorm> : 0;; DUP IF ELSE DROP EXIT THEN ;
17:42:32 <tangentstorm> ok.. that looks like it would work but i'd probably break it into smaller pieces.
17:44:28 <tangentstorm> : next2 ( aa ab - aa1 ab1 ca cb ) 2dup c@ swap c@ ;  \ or something...
17:46:53 --- join: nighty-_ (~nighty@CPE0026f3096ae8-CM0026f3096ae5.cpe.net.cable.rogers.com) joined #forth
17:46:56 <nys> hrm
17:48:18 <tangentstorm> not sure that increments the address i guess..
17:53:42 <nys> i can't seem to get it shorter than 19
17:59:29 --- quit: mnemnion_ (Remote host closed the connection)
18:00:00 <tangentstorm> so break it into separate words
18:01:50 <nys> but i'd still count the bodies of the additionally defined words as well
18:02:44 <tangentstorm> then you should count the bodies of the words you used, too.
18:03:22 <nys> i'll only count words that i defined myself, not standard words
18:03:23 --- quit: pvt_petey (Quit: Computer has gone to sleep.)
18:03:44 <tangentstorm> then just use 'compare' :)
18:03:53 <nys> @_@
18:04:20 <KipIngram> Why aren't we counting bytes instead of words?
18:04:40 <KipIngram> Bytes and cycles are the only metrics that really matter.  Everything else can be "shuffled around."
18:05:52 <nys> words are more or less bytes
18:06:01 <nys> or proportional to bytes
18:06:05 <nys> and are easier to count
18:07:37 <tangentstorm> looks like retro's implementation is longer than yours
18:08:18 <nys> i know, i checked :(
18:08:19 <KipIngram> We're trying to compare two strings?
18:08:40 <nys> yes, specifically in the case where you want to check whether they're equal
18:08:50 <KipIngram> Stack input?
18:08:50 <tangentstorm> repeat dup, @, push, 1+, swap, dup, @, push, 1+, pop, dup, pop, !if drop, drop, dup, xor, ; then 0 # 12 m, m, drop, drop, -1 # ;
18:08:55 <KipIngram> a1 n1 a2 n2 ?
18:09:01 <nys> a1 a2 n
18:09:11 <KipIngram> Ok.
18:09:19 <nys> unless there's a shorter one for a1 n1 a2 n2 i suppose
18:09:44 <KipIngram> Probably not - your way starts with the assumption the lengths are equal, so that doesn't have to be checked.
18:10:22 <tangentstorm> (but retro uses 0-terminated strings, and that comes early enough in the bootstrap process that it's mostly assembly) 
18:10:28 <KipIngram> And the rules are that we count bodies of words defined to solve the problem?
18:10:43 <nys> yeah
18:12:13 <KipIngram> Return a flag on the stack?  0 if equal and 1 otherwise?
18:12:31 <KipIngram> Or rather 0 if equal and nonzero otherwise?
18:12:49 <nys> hm
18:13:03 <nys> the definition i gave does -1 for equal and 0 otherwise
18:13:08 <KipIngram> Ok.
18:13:10 <KipIngram> That's fine.
18:13:16 <nys> i suppose you can use whatever condition makes it the shortest :D
18:13:22 <KipIngram> It's just that C returns 0 for equal.
18:13:41 <nys> as long as the resulting condition doesn't need you to do any additional computation to use it
18:14:36 <nys> additional computation such as doing the actual comparing part of the operation :D
18:19:08 <tangentstorm> you need to do more work to return -1 i would think.
18:19:34 <nys> probably
18:20:01 <tangentstorm> it's probably cheaper to return 0 if they're equal and -1 or +1 to indicate which one is greater.
18:20:27 <tangentstorm> or even just the amount by which it's greater.
18:20:44 <tangentstorm> since then you could just subtract letters and check for 0
18:26:19 <nys> variable sum : str= 0 do 2dup c@ sum +! c@ sum -! 1+ swap 1+ loop 2drop sum @ ;
18:26:37 <nys> counting "variable" that's 18
18:28:14 <KipIngram> What's the shortest we have so far?
18:29:08 <KipIngram> And if we define lower level words we only count the total of *body* words?
18:29:13 <KipIngram> Headers are irrelevant?
18:29:31 <nys> yeah
18:29:43 <nys> and the shortest we have so far is one i just made
18:30:01 <nys> which is 17 if you exclude variable as a sort of header
18:31:10 <tangentstorm> why do you need sum?
18:31:48 <nys> repeatedly add character from first word, subtract character from second
18:32:22 <nys> okay nevermind, that won't work unless there's a check for zero at each step
18:32:41 <tangentstorm> how about xor
18:32:44 <nys> so the shortest one is still 19
18:32:52 <tangentstorm> c@ sum xor c@ sum xor 
18:33:11 <tangentstorm> and now you can factor those three words out
18:33:24 <tangentstorm> er
18:33:47 <tangentstorm> well it would have to be xor! i guess 
18:35:13 <tangentstorm> : cx! c@ sum xor ! ;   then    cx! cx! sum 0 = if ...
18:35:57 <tangentstorm> that word could also increment and swap
18:36:40 <KipIngram> If it works on gforth is that a "pass"?
18:36:56 <tangentstorm> : cx! dup c@ sum xor ! 1+ swap ;
18:37:42 <nys> gforth is a pass
18:38:14 <nys> tangentstorm, i like your thinking :)
18:38:16 <tangentstorm> : str= 0 do cx! cx! sum 0= if -1 unloop exit then loop 0 ;
18:38:34 <tangentstorm> (untested and probably wrong) :)
18:39:16 <tangentstorm> still 19 by your measure though
18:39:23 <tangentstorm> beats me
18:40:10 <nys> shoot
18:40:14 <tangentstorm> hrm.. i bet you don't need sum though.
18:40:32 <nys> it's at least a prettier 19 than the one before
18:41:16 <tangentstorm> you could probably use rot instead of sum, and just juggle the string counters
18:41:20 <tangentstorm> also i think there's c
18:41:25 <tangentstorm> er c>
18:42:22 <nys> gforth doesn't seem to have it :(
18:43:08 --- join: koisoke (xef4@epilogue.org) joined #forth
18:44:14 <tangentstorm> i was thinking of  >in and it's not what you want.
18:44:29 <nys> oh
18:45:48 <tangentstorm> also doesn't it have to be sum @
18:48:18 * tangentstorm is spoiled by type checkers and is now too lazy to write good forth. :)
18:48:30 <nys> :D
18:49:23 <nys> this is my slight variation of yours: : str= 0 do cx! cx! sum 0= if leave then loop 2drop sum @ ;
18:52:07 <tangentstorm> oh, i didn't know about leave. cool.
18:53:02 <tangentstorm> should also be 'sum @ 0='
18:54:26 <tangentstorm> : cx! dup c@ sum @ xor sum ! 1+ swap ; \  i think
18:54:40 <nys> oh yeah
18:55:27 <nys> 23 ack
18:56:24 <tangentstorm> i think rot would save us at the expense of some readabilty.
18:57:21 <nys> readability is our enemy
18:58:43 <tangentstorm> start with (a0 a1 0) on the stack inside the loop...
18:59:58 <tangentstorm> : cx (a0 a1 x -- a1 a0 [x xor ch] ) rot dup ch@ xor swap ;
19:00:58 <tangentstorm> : cx (a0 a1 x -- a1 a0 [x xor ch] ) rot dup ch@ xor ;
19:03:07 <tangentstorm> : str= 0 do 0 cx cx dup if leave then >r 2drop r> ; 
19:03:22 <tangentstorm> : str= 0 do 0 cx cx dup if leave then loop >r 2drop r> ; 
19:04:31 <tangentstorm> result would be 0 if same else ... the first differing characters xored together i guess.
19:04:40 <KipIngram> Are we still at 17?
19:04:57 <KipIngram> tangentstorm: you just posted a promising inner sequence, right?  Not a full solution?
19:04:58 <nys> it seems like we're at 19
19:05:07 <KipIngram> Oh, I think I have a gforth legit 17.
19:05:14 <KipIngram> Hang on and I will post.
19:05:30 <tangentstorm> i think what i just posted will actually run.
19:05:33 <nys> oh sweet
19:05:38 <KipIngram> Helper word: 
19:05:44 <nys> i think you might have missed the increment
19:05:49 <KipIngram> : overj+@ over j + @ ;
19:05:54 <KipIngram> I assume that counts as 4.
19:06:15 <tangentstorm> ah yeah that's why i had the swap. i just forgot. good point.
19:06:15 <nys> yeah
19:07:19 <KipIngram> : str= FFFFFFFF. do -rot overj+@ overj+@ = >r rot r> and loop -rot 2drop ;
19:07:29 <KipIngram> And that's 13.
19:07:46 <KipIngram> I haven't tested it. 
19:07:49 <KipIngram> Just scritinized it.
19:07:53 <KipIngram> scrutinized
19:08:08 <KipIngram> But I checked to make sure that the use of j in overj+@ is valid.
19:08:30 <nys> what does that actually do?
19:08:31 <KipIngram> There's a return address on the stack, so "i" is a level deeper.
19:08:33 <KipIngram> Hence j.
19:08:45 <KipIngram> overj+@?
19:08:55 <KipIngram> I should have called it overi+@.
19:09:02 <KipIngram> Because that's what it really does in the higher level word.
19:09:10 <nys> ohhhhh
19:09:14 <nys> okay
19:09:19 <KipIngram> Sorry - poor name choice.
19:09:42 <KipIngram> My first cut had the idiom "over i + @" twice, and I realized I could factor it into a definition if I used j instead of i.
19:10:10 <KipIngram> It's almost cheating - it counts on the implementation-specific use of the return stack for i and j.
19:10:17 <nys> what's FFFFFFFF. ?
19:10:26 <KipIngram> That is equivalent to -1 0
19:10:26 <nys> it doesn't seem to work on my gforth
19:10:36 <tangentstorm> say hex first.
19:10:47 <nys> oh.
19:10:49 <KipIngram> Oh, good point.
19:11:01 <KipIngram> So if you didn't want to say hex first you'd have to use some other weird number.
19:11:12 <KipIngram> But if you type -1 0 d. it will tell you what that number needs to be.
19:11:38 <tangentstorm> hex doesn't really affect the program length though
19:11:46 <nys> yeah
19:11:55 <KipIngram> Well, you could use a decimal number to achieve the same thing.
19:12:21 <KipIngram> 4967295.
19:12:37 <KipIngram> Typo.
19:12:53 <KipIngram> 4294967295.
19:14:04 <nys> what does the period at the end do?
19:14:40 <tangentstorm> seems to put a 0 on the stack
19:15:36 <nys> well i mean i know but what is it meant for? :)
19:15:47 <nys> the feature that lets you put that there
19:16:14 <tangentstorm> probably from the old days when cells were 16 bits
19:16:39 <nys> oh it's a double precision integer
19:16:40 <tangentstorm> so you could use 32 bit numbers.. that's a wild guess.
19:16:43 <KipIngram> Yes.
19:16:53 <KipIngram> It gets you a -1 flag and a 0 to start the do loop in one shot.
19:17:00 <KipIngram> Sneaky, but valid.
19:17:22 <KipIngram> And it's for 32-bit cells.
19:17:49 <KipIngram> My gforth is 32-bits, and it works there.
19:20:07 <tangentstorm> '-1. 1+'  works too but costs a token.
19:20:54 <tangentstorm> but looks pretty :)
19:21:38 --- quit: nighty-_ (Ping timeout: 245 seconds)
19:21:49 <KipIngram> Oh, I have it shorter by one.
19:22:34 <KipIngram> Oh, no I don't.  Same.
19:23:44 <KipIngram> No wait.  It is shorter.  Replace the >r rot r> and with 3 roll and
19:23:49 <KipIngram> So that's 16.
19:24:33 <KipIngram> I guess I should go test this.
19:27:06 <KipIngram> Heh heh heh.
19:27:10 <KipIngram> Hung my system - something is wrong.
19:27:14 <KipIngram> Maybe I typed it in wrong.
19:27:24 <tangentstorm> hrm i have an idea
19:27:52 <tangentstorm> it's slower but smaller.
19:29:29 <nys> small is the goal!!
19:30:02 <KipIngram> Oh, ok.
19:30:10 <KipIngram> Mine is wrong.
19:30:17 <KipIngram> The FFFFFFFF. thing is misguided.
19:30:38 <KipIngram> Yes, it gets you the flag and the 0 at the same time, but that's not right for kicking off the do loop.
19:30:55 <KipIngram> You want <length> 0 for that, not <flag> 0.
19:31:10 <KipIngram> So we have to have -1 swap 0 instead, so I'm back up to 18.
19:31:31 <KipIngram> But I guess that's still better than 19.
19:31:34 <KipIngram> Trying that now.
19:31:34 <tangentstorm> : hash (a n - x) 0 swap 0 do dup ch@ xor swap loop ;  \ untested
19:33:05 <KipIngram> Or, let's just use dup 0.  Any non-zero number should do for the initial flag.
19:33:13 <KipIngram> That might fail on 0 length strings, though.
19:33:19 <KipIngram> That would cut it back to 17.
19:35:30 <nys> hooray
19:35:45 <tangentstorm> : str= (a0 a1 n - f) swap over hash hash = ;
19:36:07 <tangentstorm> : hash (a n - x) 0 swap 0 do dup ch@ xor swap 1loop ;  \ untested
19:36:12 <tangentstorm> : hash (a n - x) 0 swap 0 do dup ch@ xor swap 1+ loop ;  \ untested
19:36:36 <tangentstorm> 14 if i'm counting right and it actually works.
19:36:43 <nys> what?!
19:36:46 <nys> it shouldn't
19:37:03 <tangentstorm> why not?
19:37:05 <KipIngram> Wow.
19:37:22 <tangentstorm> you could use + instead of xor
19:37:36 <KipIngram> Hang on - I'm trying that.  That's cool.
19:37:50 <nys> because if you go through it step by step it seems like that you're executing 0 ch@
19:38:31 <tangentstorm> no it's only looking at one string at a time.
19:39:02 <tangentstorm> ah hrm.
19:39:09 <tangentstorm> 2swap?
19:39:17 <tangentstorm> no that would be silly :)
19:39:26 <KipIngram> Well, it's c@, not ch@.
19:39:29 <KipIngram> But no worries.
19:39:54 <tangentstorm> 0 swap 0  was meant to leave  'string-length 0 ' atop the stack for 'do'
19:40:02 <KipIngram> It crashed.
19:40:34 --- join: kumool (~mool@adsl-64-237-224-98.prtc.net) joined #forth
19:40:41 <KipIngram> I'll let you work on yours - I'm still troubleshooting mine.
19:40:42 <tangentstorm> but that leavs  a 0  on the stack, and really i wanted 0 a
19:41:23 <nys> it would appear you need to increment also i think
19:41:28 <nys> increment a
19:41:36 <tangentstorm> that's what the 1+ is for
19:41:58 <nys> oops
19:42:04 <nys> i was using your older one
19:43:09 <tangentstorm> hrm. how do i put a string on the stack in gforth?
19:43:22 <tangentstorm> " cat" doesn't work.
19:43:31 --- quit: kumul (Ping timeout: 260 seconds)
19:44:37 <nys> s" cat"
19:44:45 <tangentstorm> thanks
19:44:46 <nys> how about this: : hash 0 swap 0 do swap dup c@ >r swap r> xor 1+ loop nip ;
19:46:25 <tangentstorm> i think we can get by with just the one stack without adding any tokens
19:46:44 <nys> nevermind what i just wrote
19:48:04 <KipIngram> My use of j isn't doing what I thought.
19:48:07 <nys> it counts the letters in the string if it's an even number of letters and if it's an odd number of letters it does... weird things
19:48:10 <KipIngram> Thought I thought I tested it.
19:55:53 <nys> my first 19-word definition requires a <> instead of a =
19:56:13 <nys> but it otherwise works
19:57:20 <tangentstorm> : hash ( a n - ) 0 -rot 0 ?do ( x a ) dup c@ rot + swap 1+ loop drop ;  \ tested. s" cat" hash -> 13
19:57:26 <tangentstorm> er -> 312
19:59:04 <nys> well, it looks that makes it the shortest working one
20:00:59 <tangentstorm> it's easier if it has (a0 n0 a1 n1) to start
20:01:16 <nys> that's what i was counting by
20:01:52 <tangentstorm> : str= ( a0 n0 a1 n1 ) hash -rot hash = ;
20:02:09 <tangentstorm> s" cat" s" cat" str= .s <2> -1 -1  ok
20:02:42 <tangentstorm> er.. one of those '-1' was left over from before
20:03:14 <tangentstorm> still 15 though
20:03:24 <nys> although if KipIngram gets theirs working, it will be the shortest to be true equality :D
20:03:35 <tangentstorm> hrm wait
20:04:30 --- quit: Ethical (Ping timeout: 265 seconds)
20:06:28 <nys> if you change the c@ in hash to @, then it can distinguish a lot more strings
20:07:02 <tangentstorm> widechars, you mean?
20:07:36 <nys> just interpreting the string as a series of overlapping integers
20:07:58 <nys> the characters are the same size but you can take in a bunch at a time
20:08:03 <KipIngram> Ok, I have an 18-word solution that's tested.
20:08:29 <nys> hoorah
20:08:33 <KipIngram> But - it leaves a nonzero flag rather than -1.
20:08:41 <KipIngram> And, I think it would fail if the strings were of length 0.
20:08:56 <KipIngram> As in I think it would return 0.
20:09:02 <KipIngram> And two zero length strings match.
20:09:03 <nys> it's still probably fascinating to look at :D
20:09:05 <KipIngram> So that's not quite right.
20:09:12 <KipIngram> It close to what I already posted.
20:09:23 <KipIngram> Still looking at it, though.
20:12:06 <KipIngram> Although it looks like 0 0 do i . loop goes crackers in gforth .  1 0 do ... loop does a single iteration.  0 0 do ... loop does maxint iterations, apparently.
20:12:22 <KipIngram> So that pretty much hoses any solution that attempts to use a straight up do loop in the zero length case.
20:12:31 <KipIngram> So I propose we set aside the zero length case.
20:12:41 <nys> that's fine
20:12:44 <KipIngram> And I propose we accept any non-zero flag as equality.
20:13:00 <KipIngram> Or rather as "true."
20:13:13 <nys> i said you can have any two flags for either case as long as you can tell them apart, eheh
20:13:13 <KipIngram> Is there a Boolean and in Forth?
20:13:21 <KipIngram> AND seems to be a bit-wise and.
20:15:20 --- join: mnemnion (~mnemnion@c-98-210-219-91.hsd1.ca.comcast.net) joined #forth
20:15:35 <KipIngram> I can tack a 0> on at the end and it converts flag to -1, but that moves the count to 19.
20:15:57 <nys> you can use whatever flags you want
20:16:11 <tangentstorm> KipIngram: use '?do' instead of 'do'
20:17:55 <KipIngram> Yes, I think we can.
20:18:04 <KipIngram> And that would leave the correct flag on the stack.
20:18:05 <KipIngram> Nice.
20:18:19 <KipIngram> And, I figured out that if I use u> instead of and I get the result I want.
20:18:31 <KipIngram> I think this has us to 18 with something that works for all strings.
20:18:31 <KipIngram> Stand by.
20:18:52 --- join: Ethical (~sam@139.216.253.31) joined #forth
20:18:59 <tangentstorm> my version doesn't work with all strings? :/
20:19:22 <nys> your version reports palindromes as equal
20:19:23 <tangentstorm> http://pastebin.com/dj8v0h06
20:19:28 <tangentstorm> er
20:19:29 <KipIngram> Ok, I meant u<.
20:20:02 <tangentstorm> ignore that link, it's just garbage
20:20:26 <KipIngram> Wait.
20:20:49 <KipIngram> the ?do trick will keep the code from crashing on zero length strings, but it doesn't leave a -1 on the stack.  It still fails.
20:20:58 <tangentstorm> hrm. good point.
20:21:05 <KipIngram> Well, it will leave the -1 on the stack if I start off with -1 swap 0 do.
20:21:27 <KipIngram> But if I start with dup 0 do it will leave the 0 on the stack.
20:21:53 <KipIngram> So if we insist on a correct result for the 0 length case then we have to accept -1 swap 0 do.
20:21:58 <tangentstorm> what about something crazy that takes the distance in ram between the two strings, fetches both characters, and then does the comparison? 
20:22:26 <nys> i thought about that a while ago while pacing around in my hallway :D
20:22:29 <KipIngram> And that's a 19-length answer.
20:22:50 <KipIngram> I thought of that earlier too, but I'm not sure that will shorten it.
20:22:57 <KipIngram> I didn't smell a win strongly enough to go after it.
20:23:16 <nys> KipIngram: i wouldn't insist on a correct answer for 0 length strings
20:23:55 <KipIngram> Ok, in that case then I can give you 18.
20:24:00 <nys> hooray
20:24:17 <KipIngram> I'm still trying to trim it, though.
20:24:28 <KipIngram> And for nonzero length strings it will give a good 0 / -1 answer.
20:25:28 <nys> could i see so far? :)
20:25:33 <nys> because i ought to get to bed
20:25:51 <tangentstorm> CREATE> lit , lit  , 
20:25:54 <tangentstorm> er
20:26:08 <tangentstorm> me too. this was fun though.
20:27:08 <nys> i'm glad i could give the spark :D
20:28:30 <KipIngram> Whoa - I think I'm back down to 17.
20:28:43 <KipIngram> nys: yes, let me run a quick test and I'll post.
20:28:48 <KipIngram> Give me 3-4 minutes.
20:28:53 <nys> sweet alright
20:34:54 --- quit: Zarutian (Quit: Zarutian)
20:35:22 <KipIngram> Ok.  So something is still a bit off about it.  I'll post the correction shortly.  But here is what I have at the moment:
20:35:30 <KipIngram> : overi+c@' over j + c@ ;
20:35:40 <KipIngram> : overi+c@ overi+c@' ;
20:36:02 --- quit: malyn (Ping timeout: 252 seconds)
20:36:53 <KipIngram> : str= -4294967296 -rot do overi+c@ overi+c@ = 3 roll and -rot loop 2drop ;
20:37:12 <KipIngram> Oh, that number should have a period at the end.
20:37:27 <KipIngram> I count that as 4 + 1 + 12 = 17.
20:37:41 <nys> yeah
20:38:20 <KipIngram> Actually I believe that if you replace do with ?do it will work for zero length strings, with a -1 flag returned in all cases where the strings match.
20:38:25 <KipIngram> But, like I said, something is a tad off.
20:38:31 <KipIngram> I'll figure it out.
20:39:52 <KipIngram> Oh, I see why it won't work.
20:42:03 --- join: malyn (~malyn@unaffiliated/malyn) joined #forth
20:45:39 <KipIngram> Ok, so this is tested and works, but not for the zero-length case.  Code length 18:
20:45:44 <KipIngram> : overi+c@' over j + c@ ;
20:45:56 <KipIngram> : overi+c@ overi+c@' ;
20:46:55 <KipIngram> : str= dup 0 do -rot overi+c@ overi+c@ = 3 roll u> loop -rot 2drop ;
20:47:43 <KipIngram> tangentstorm: did you get yours working?
20:50:00 <nys> (yes!)
20:50:53 <KipIngram> ?
20:50:58 <KipIngram> Yes he did?
20:51:07 <nys> : hash ( a n - ) 0 -rot 0 ?do ( x a ) dup c@ rot + swap 1+ loop drop ;       : str= ( a0 n0 a1 n1 ) hash -rot hash = ;
20:51:33 <KipIngram> I count that as 15.
20:51:33 <nys> he did
20:51:53 <KipIngram> Wait - 16.
20:52:09 <nys> i count 16 also
20:52:17 <KipIngram> Very sweet.  :-)
20:52:33 <nys> but unable to tell palindromes apart
20:52:43 <KipIngram> Yes, I'm trying to figure out what the hell it does.
20:53:14 <nys> it compares the sum of the letters of the two strings
20:53:24 <KipIngram> Hold it.
20:53:29 <KipIngram> That's not a proper test.
20:53:45 <KipIngram> What it return for abcde and abced?
20:53:57 <KipIngram> Those just have two letters transposed.
20:53:57 <nys> it reports them as equal
20:54:01 <KipIngram> They would sum to the same.
20:54:05 <nys> exactly
20:54:19 <KipIngram> Mine would fail those.
20:54:29 <KipIngram> Rather it would report them as failing to match.
20:54:48 <nys> that's why i said earlier that yours was the shortest true test
20:54:52 <KipIngram> But it's still a very nice bit of code.
20:55:50 <nys> if you replace the c@ with @ then when looking at a word like "cat" it will sum 'cat?' 'at??' 't???' instead of 'c' 'a' 't'
20:56:10 <nys> and it's still not a proper test but it's less likely for there to be two words with the same sum
20:56:27 <KipIngram> Yes.
20:57:58 <KipIngram> Oh, ok - I remember seeing you mention that.  I was too focused on my own debugging to really follow that at the time.
20:58:50 <nys> this was fun :D
20:58:55 <nys> time for sleep
20:59:11 <nys> night night
21:00:40 <KipIngram> Night - that was fun.
21:00:40 <KipIngram> Thanks.
21:01:00 <nys> :-)
21:01:07 --- quit: nys (Quit: sleep)
21:43:26 --- nick: ASau` -> ASau
22:25:52 --- quit: kumool (Quit: Leaving)
23:59:59 --- log: ended forth/14.02.08