|
25
|
1 2003-08-12.txt:18:56:53: <Taaus> But I really don't like reading books on my computer. I prefer dead-tree versions :)
|
|
|
2 2003-09-08.txt:13:44:35: <Doppelganger> Verbed: wn, web1913, and devils reciping: web1913: Extremely \Es`o*ter"ic\, a. Morosity be sacristy our perhaps; providencer's; salestrimmer; confederate; as, an eshtree provost; any estarr meeting; wn: extraomnes attack : convenient to and under be only an emulously inner caraculacticors; "a completed of ester palseyputred there's" [ant: {exoteric}]; web1913: Eggdrazzles (4 more messages)
|
|
|
3 2004-05-04.txt:00:52:52: <andreou> (plus, i would have to break the chroot or create a local tree with perl+libs)
|
|
|
4 2004-05-04.txt:01:04:48: <Toreun> I'm thinking for organizing wiki link trees and other random stuff?
|
|
|
5 2004-05-04.txt:03:52:30: <andreou> hm i need something that won't need a whole libc+perl tree
|
|
|
6 2004-06-25.txt:09:15:40: -!- andreou has quit ("A tree excells at being a tree.").
|
|
|
7 2004-06-25.txt:11:20:43: -!- andreou has quit ("A tree excells at being a tree.").
|
|
|
8 2004-06-25.txt:11:46:13: -!- andreou has quit ("A tree excells at being a tree.").
|
|
|
9 2004-06-25.txt:15:57:08: -!- andreou has quit ("A tree excells at being a tree.").
|
|
|
10 2004-06-25.txt:20:36:01: -!- andreou has quit ("A tree excells at being a tree.").
|
|
|
11 2004-07-12.txt:21:04:32: <mtve> usually it's a recursive parser that returns tree of operations. then you build your code by walking the tree.
|
|
|
12 2004-07-12.txt:21:04:52: <calamari_> right, but it builds the wrong tree
|
|
|
13 2005-02-25.txt:05:06:12: * heatsink is reading about red-black trees
|
|
|
14 2005-02-25.txt:05:06:41: <heatsink> My neighbor had a tree that was kinda red-black.
|
|
|
15 2005-03-11.txt:03:54:52: <{^Raven^}> and I'm just integrating Easel into the new source tree
|
|
|
16 2005-04-13.txt:14:14:28: -!- Treemole has joined #esoteric.
|
|
|
17 2005-04-13.txt:14:14:54: -!- Treemole has quit (Client Quit).
|
|
|
18 2005-05-04.txt:19:38:08: <GregorR-L> If that logic tree is to totally random to decipher, tell me, I might be able to change it around a bit :-P
|
|
|
19 2005-05-04.txt:21:01:28: <GregorR-L> Umm, possibly. I could definitely fix the logic tree of doom ^_^
|
|
|
20 2005-05-06.txt:22:59:14: * KnX wants tree-oriented Mozilla tabs
|
|
|
21 2005-05-22.txt:01:14:36: <calamari_> kipple: just looked because I was curious about MoinMoin.. it stores the pages in a directory tree
|
|
|
22 2005-05-26.txt:15:18:25: <pgimeno> instead of one plus a tree
|
|
|
23 2005-05-26.txt:15:19:11: <kipple> and you could put the db-dumps in the file tree, and do it in one op
|
|
|
24 2005-05-26.txt:15:23:32: <malaprop> pgimeno: I think he was saying the svn dump should be copied into the wiki tree.
|
|
|
25 2005-05-26.txt:15:25:47: <malaprop> That will be in the wiki tree, we've already planned for it.
|
|
|
26 2005-05-26.txt:16:09:28: <pgimeno> you can download the subversion tree with wget via web, for example
|
|
|
27 2005-05-26.txt:23:26:41: <pgimeno> graue: that's not bad for tarball distributions; it's bad for tree structures à la Cat's Eye
|
|
|
28 2005-05-27.txt:00:17:08: <graue> you would checkout svn, copy a file into your tree and svn add it
|
|
|
29 2005-05-28.txt:18:52:03: <kipple> well, if svn doesn't have a problem with the wiki writing into the file tree, then that would work
|
|
|
30 2005-05-29.txt:13:14:47: <jix> i tokenize the code into a linked tree and the loop instruction forks the tree
|
|
|
31 2005-05-29.txt:14:04:41: <jix> uh.. i thought it was the interpreter.. but it was the token-tree-freeer
|
|
|
32 2005-05-29.txt:15:01:45: <jix> i wrote a small debug feature that allows me to dump out the token-tree (the output is valid kipple)
|
|
|
33 2005-06-03.txt:22:32:13: <pgimeno> someone said recently in the GMP mailing list: 'C' gives you enough rope to hang yourself, and will even do the favor of throwing one end of the rope over the tree for you ...
|
|
|
34 2005-06-07.txt:00:00:56: <pgimeno> do you want to add the whole src/ tree with all of its contents?
|
|
|
35 2005-06-09.txt:10:45:11: <DMM> indeed he has. A lot of tree-based ones though...
|
|
|
36 2005-06-17.txt:21:49:57: <pgimeno> c:ppddcust.exe /name="John Doe" /address="666th street, Moon" /phone="(+12)3456789"
|
|
|
37 2005-06-21.txt:17:55:51: <graue> how about a homeless kid finds a discarded laptop on the streets of a city slum, connects to an unsecured wireless network, and begins learning about esoteric programming languages?
|
|
|
38 2005-07-24.txt:21:56:37: <jix> and some o11s within the loop tree
|
|
|
39 2005-07-24.txt:22:32:30: <jix> 1 that works on the brainfuck source 1 that does the bf-tree => intermediate-lang and 1 that removes dead code from the intermediate-lang
|
|
|
40 2005-08-21.txt:05:28:07: <tokigun> i'm planning (or thinking) esolang which uses binary tree as data structure. there's such the esolang?
|
|
|
41 2005-08-21.txt:05:29:09: <WildHalcyon> Im not familiar with any esolang that uses trees. A generic binary tree, or do you have a more specific one in mind?
|
|
|
42 2005-08-21.txt:05:29:49: <tokigun> i mean generic binary tree... maybe.
|
|
|
43 2005-08-21.txt:05:30:50: <tokigun> each node has one integer as data, and the program travels the tree.
|
|
|
44 2005-08-23.txt:06:06:56: * calamari hides from WildHalcyon's B-Tree
|
|
|
45 2005-08-23.txt:06:07:24: <WildHalcyon> you think a B-Tree is the worst up my sleeve?
|
|
|
46 2005-08-23.txt:06:09:16: <WildHalcyon> right now, Im debating between a treap, a k-d tree, and a pairing heap
|
|
|
47 2005-08-23.txt:06:15:53: <WildHalcyon> Yeah, I like k-d trees
|
|
|
48 2005-08-23.txt:06:32:04: <nooga> what are k-d trees?
|
|
|
49 2005-08-23.txt:06:37:59: <WildHalcyon> Right, essentially, a 2-d tree has two types, a 3-d tree has three types to search among, etc.
|
|
|
50 2005-08-23.txt:06:38:40: <calamari> hope that makes some kind of sense.. I have no really studied these trees :)
|
|
|
51 2005-08-23.txt:06:40:35: <WildHalcyon> That's pretty much it. At each level of the binary tree, sort based on different types of data
|
|
|
52 2005-08-23.txt:06:43:14: <calamari> but you'll also want to be able to manipulate the tree
|
|
|
53 2005-08-23.txt:06:57:20: <calamari> hmm, maybe it's just been too long since data structures, but it doesn't seem like trees and arrays really mix, unless it's a non-bst
|
|
|
54 2005-08-26.txt:04:18:44: <WildHalcyon> Yeah, its a type of binary tree with some heap properties
|
|
|
55 2005-09-18.txt:17:40:38: <Wildhalcyon> Im not sure how that integer sequence (which deals with anti-chains in "rooted trees" ?) relates to the symbol problem though
|
|
|
56 2005-09-18.txt:18:05:05: <Wildhalcyon> Im trying to design a tree structure out of it, but its difficult
|
|
|
57 2005-09-20.txt:04:46:12: <Arrogant> As well as operators for walking up and down a scope tree
|
|
|
58 2005-09-27.txt:22:35:35: <Wildhalcyon> I like street cred
|
|
|
59 2005-09-27.txt:22:35:53: <GregorR-L> But it's street cred associated with Microsoft.
|
|
|
60 2005-09-27.txt:22:36:09: <GregorR-L> That's like the street cred from being a Visual Basic guru :-P
|
|
|
61 2005-10-07.txt:19:56:59: <jix> for a hash trees tables... the coverage over all bits is important
|
|
|
62 2005-10-11.txt:05:52:06: <nooga> if we have strong wind here, it can break a tree or take crappy roof away
|
|
|
63 2005-10-28.txt:23:08:46: <Aardwolf> well meanwhile, check out this :) http://www.rense.com/general67/street.htm
|
|
|
64 2005-10-30.txt:15:05:05: <fizzie> In London the 'hybrid' view used to have the streets few metres off the satellite view, let's see if they still have that problem...
|
|
|
65 2005-10-31.txt:22:05:04: <calamari> wow the streets to the left of GregorR's pointer look like a navigation nightmare
|
|
|
66 2005-10-31.txt:22:05:35: <kipple> hmm. if you zoom in on the satelite map you can see that Gergor lives under a tree.
|
|
|
67 2005-10-31.txt:22:13:15: <Robdgreat> A Moxie tree, no doubt.
|
|
|
68 2005-11-14.txt:23:51:09: <calamari> string -> tree
|
|
|
69 2005-11-15.txt:14:10:14: <kipple> seen this: http://skystreets.kaosfusion.com/ ?
|
|
|
70 2005-11-25.txt:20:11:51: <jix> there was a way to dump the gcc gimple tree (for making a c => linguine compiler)
|
|
|
71 2005-11-25.txt:23:16:37: <jix> that's a tree build from ruby arrays.... not a program...
|
|
|
72 2006-01-04.txt:20:53:07: <ihope> I'm trying to write a Haskell interpreter for it. Treeky, it is.
|
|
|
73 2006-01-07.txt:04:55:22: <fizzie> Well, you can easily have a 'choose your own adventure'-type of story tree thing (or other forms of 'choose from a predefined set of options, do decisions based on that'), but that's about it. (As far as I know, and the specs are oh-so-secret - there are few pages on the internet, and the dvdauthor documentation and source.)
|
|
|
74 2006-01-27.txt:19:12:55: <nooga> he doesn't know how to implement tree walking
|
|
|
75 2006-01-27.txt:21:22:32: <Keymaker> ..and what is tree walking?
|
|
|
76 2006-01-27.txt:21:23:04: <jix> you have a tree (data structure) and you visit all nodes in some order
|
|
|
77 2006-02-01.txt:01:42:32: <GregorR> If you divide up the parse tree enough and make liberal use of temporary variables, it shouldn't be such a huge problem.
|
|
|
78 2006-02-01.txt:20:46:23: <GregorR> Maybe I ought to bark up that tree.
|
|
|
79 2006-02-02.txt:15:27:31: <{^Raven^}> all the changes are in the bfbasic CVS tree
|
|
|
80 2006-02-02.txt:23:23:08: <GregorR-L> I need to get my AST tree generator done so you can play with C2BF instead 8-D
|
|
|
81 2006-02-03.txt:16:34:54: <ihope> "Rough-coated, dough-faced, thoughtful ploughman John Gough strode through the streets of Scarborough; after falling into a slough on Coughlin road near the lough (dry due to drought), he coughed and hiccoughed, then checked his horse's houghs and washed up in a trough!"
|
|
|
82 2006-02-04.txt:06:44:59: <GregorR> So in this compiler's parser, I have a bunch of nonterminals. I have 14 left to make a tree out of.
|
|
|
83 2006-02-07.txt:05:17:34: * Arrogant plays some Porcupine Tree
|
|
|
84 2006-02-08.txt:06:27:37: <GregorR> There are for CST (concrete syntax tree)
|
|
|
85 2006-02-21.txt:15:21:39: <nooga> i'm looking for a way to check if a tree is a subtree of another
|
|
|
86 2006-02-21.txt:15:23:57: <nooga> binary tree
|
|
|
87 2006-02-21.txt:15:24:09: <SimonRC> isSubTree n m@(Node _ l r) = n == m || n `isSubTree` l || m `isSubTree` r
|
|
|
88 2006-02-21.txt:15:25:56: <nooga> i've got a tree in such format
|
|
|
89 2006-02-21.txt:15:29:41: <nooga> trees
|
|
|
90 2006-02-21.txt:15:30:05: <SimonRC> They look like lists, not trees
|
|
|
91 2006-02-21.txt:15:44:04: <SimonRC> what's your tree type?
|
|
|
92 2006-02-21.txt:15:44:46: <nooga> make it compatible with: isSubTree n m@(Node _ l r) = n == m || n `isSubTree` l || m `isSubTree` r
|
|
|
93 2006-02-21.txt:15:45:43: <SimonRC> data Tree a = Node a (Tree a) (Tree a) | Nil
|
|
|
94 2006-02-21.txt:15:48:05: <SimonRC> erm, what data do you want in your trees?
|
|
|
95 2006-02-21.txt:16:31:05: <nooga> In the definition of `isSubTree':
|
|
|
96 2006-02-21.txt:16:31:05: <nooga> isSubTree n (m@(Node _ l r))
|
|
|
97 2006-02-21.txt:16:31:05: <nooga> = (n == m) || ((n `isSubTree` l) || (m `isSubTree` r))
|
|
|
98 2006-03-10.txt:15:49:52: <jix> you have a tree like structure
|
|
|
99 2006-03-11.txt:15:15:21: <SimonRC> but, you can make a function be parsed like a variable (being a leaf not a branch node in the parse tree) or a variable act like a function (be a branch not a leaf in the parse tree)
|
|
|
100 2006-03-11.txt:23:00:48: <Arrogant> Porcupine Tree is my favorite.
|
|
|
101 2006-03-18.txt:19:54:24: <calamari> and I used GIMP to remove a street sign
|
|
|
102 2006-04-05.txt:19:35:52: <nooga> haj maj frriendz from foregin kauntrees
|
|
|
103 2006-04-28.txt:18:54:14: <nooga> like tree or even soda can
|
|
|
104 2006-04-28.txt:18:54:28: <GregorR-W> More like a tree :P
|
|
|
105 2006-04-29.txt:00:03:26: <kate`> imagine you have a jpeg: the first thing you do is parse it into a tree
|
|
|
106 2006-04-29.txt:00:03:34: <kate`> when you're done, you serialise that tree back to a file
|
|
|
107 2006-04-29.txt:00:03:47: <kate`> why not store the parsed tree in the first place?
|
|
|
108 2006-04-29.txt:00:10:06: <kate`> kipple, your XML document is not a bunch of ascii: it's a DOM tree
|
|
|
109 2006-05-24.txt:20:31:24: <calamari> a couple days ago we drove up north for a funeral and the changing landscape (how the trees changed with elevation, etc), reminded me of my adventure game
|
|
|
110 2006-05-30.txt:22:09:30: <ihope> Then we can represent trees easily enough: 0 is S, 1 is K, 1+(x,y) is `xy.
|
|
|
111 2006-06-01.txt:16:36:34: <ihope> I say <parens> ::= "(" <parentree> | epsilon, and <parentree> ::= "(" <parentree> <parentree> | ")".
|
|
|
112 2006-06-01.txt:16:37:17: <ihope> So a set of parentheses is pretty much a list of trees of nothing in particular.
|
|
|
113 2006-06-05.txt:14:57:47: <ihope> Just parse all your input, using the "reprint character read" function to deal with the output functions. Then use a fold to turn the resulting tree into Unlambda code, and have the rest of the interpreter evaporate.
|
|
|
114 2006-06-06.txt:14:05:03: <fizzie> That thing is so very fancy; now if they'd just allow drag-n-dropping the DOM nodes in the tree.
|
|
|
115 2006-06-14.txt:23:26:27: <ihope> Now, if I'm not mistaken, it is easy for Unlambda to simulate Unlambda: just construct a tree with all your primitive thingies, then fold them into a function, which is your program.
|
|
|
116 2006-06-23.txt:22:34:39: <_W_> trees are so much simpler :(
|
|
|
117 2006-06-24.txt:22:39:37: <SimonRC> IIRC you can right-click on anything in the source tree in Netbeans and hit update to get it check for external changes
|
|
|
118 2006-07-25.txt:09:31:25: <Arrogant> Jay: Kids, if Silent Bob could talk, he'd remind you that when you're camping, it's always smart to tie your food up in a tree at night so as not to attract bears.
|
|
|
119 2006-07-31.txt:14:29:01: <GregorR> I had to use pstree O_O
|
|
|
120 2006-08-05.txt:03:55:33: <RodgerTheGreat> use dimensions like a tree structure.
|
|
|
121 2006-08-05.txt:03:57:23: <RodgerTheGreat> now, to actually store this as a data structure, you'll need a treelike system.
|
|
|
122 2006-08-05.txt:06:00:40: <RodgerTheGreat> [10:55pm] RodgerTheGreat: use dimensions like a tree structure.
|
|
|
123 2006-08-05.txt:06:00:58: <RodgerTheGreat> [10:57pm] RodgerTheGreat: now, to actually store this as a data structure, you'll need a treelike system.
|
|
|
124 2006-08-06.txt:02:02:04: <RodgerTheGreat> although, from a programmer's standpoint, it'd be equivalent to a tree... I wonder if it would make sorting algorithms easier to implement...
|
|
|
125 2006-08-15.txt:03:52:59: <RodgerTheGreat> I'd describe his topology as more 3d- a tree structure consisting of arbitrarily large 1D nodes.
|
|
|
126 2006-08-16.txt:01:39:00: <oerjanj> sesame street style then?
|
|
|
127 2006-08-20.txt:14:48:20: <pgimeno> "What if you're in a street and there's a bull coming towards you?" "I'd climb to a fence" "And if there's no fence?" "I'd look for a shop or something" "And if there's no shop" "I'd try to run to the closest corner" "And if there's a wall?" "I'd try to jump it" "And if it's too high?" "Hey, what you want is me to be caught by the bull!"
|
|
|
128 2006-08-24.txt:23:00:59: <jix> well c uses 2 different tree representations...
|
|
|
129 2006-08-29.txt:01:25:38: <GreyKnight> It's basically impossible for the computer to misparse your Lisp code, because the parse tree is there in the language itself ;-)
|
|
|
130 2006-08-30.txt:05:32:31: <GreyKnight> SHDMEABNFWXYZ-andapartridgeinapeartree
|
|
|
131 2006-08-31.txt:22:44:02: <ihope> My interpretation: the vertices must form a tree, and each edge must have a name such that there can't be two edges with the same name on one vertex.
|
|
|
132 2006-08-31.txt:23:47:46: <GreyKnight> how about as a binary tree? 'o'
|
|
|
133 2006-09-01.txt:00:58:35: <Razor-X> Uggh. Trees annoy me.
|
|
|
134 2006-09-01.txt:00:59:07: <Razor-X> Although if you want an INTERCAL-esque language, trees are the way to go ;).
|
|
|
135 2006-09-01.txt:01:00:02: <GreyKnight> I think a binary tree might be pretty useful here
|
|
|
136 2006-09-01.txt:01:00:05: <Razor-X> I guess if you want to search for something in a data structure recursively, trees are useful, but other than that.....
|
|
|
137 2006-09-05.txt:23:19:42: <pikhq> In fact, it's sufficient for plotting a full family tree.
|
|
|
138 2006-09-06.txt:07:36:24: <Razor-X> I'd hesitantly call the binary tree an advanced data structure, but I accept it. Still.... stacks?
|
|
|
139 2006-09-06.txt:07:36:42: <GregorR> I'd put a binary tree JUST under the advanced line.
|
|
|
140 2006-09-09.txt:02:30:16: <pikhq> I'll make another tarball soon as I bother cleaning up my current source tree.
|
|
|
141 2006-09-10.txt:03:15:02: <pikhq> Been fixed in my local tree for days, but the last tarball was made long before that.
|
|
|
142 2006-09-18.txt:23:45:00: <feesh> I dunno I met him on the corner of my street
|
|
|
143 2006-09-22.txt:20:59:46: <Asztal> You could use Morton numbers for keys in a binary tree
|
|
|
144 2006-09-22.txt:20:59:55: <Asztal> but, I've yet to see a binary tree in INTERCAL
|
|
|
145 2006-10-22.txt:21:15:52: <jix> one of the big advantages is that there is no sorting involved... you can work right from the probabilities... no need to generate a tree... that makes it faster for adaptive encoders
|
|
|
146 2006-10-23.txt:19:39:38: <jix> Today, we are handle decreased the daily newspaper of the first boat splendourful, [[“iynfwrm' ayshnsbwryfyk' ayshndyrktyfn]]. This traction outside of ours street, initially examined in the team [[hystwryn]], garden, request for divine the blessings the clean dish. [“ammnt] the truth causes complexes [[, the jam of the pain of the mwtsGnd]] with the all workmen, when it flowers. Us it country of the family of the state of the family of the idea
|
|
|
147 2006-10-23.txt:19:45:46: <jix> Today, we are decreased joystick the daily newspaper of first splendourful ship, [[“iynfwrm'ayshnsbwryfyk'ayshndyrktyfn]]. This pull outside from ours street, first examined in team [[hystwryn]], garden, prays for divine the benedictions the clean dish. [“ammnt] causes complex truth [[, the jam of pain of mwtsGnd]] with the all workers, when it blooms. Us the country of family of condition of family of idea of connection of troops of arm acquain
|
|
|
148 2006-10-23.txt:19:47:40: <GregorR-L> This pull outside from ours street ...
|
|
|
149 2006-10-28.txt:22:43:49: <oerjan> one thing that may not be apparent at the beginning is that the solutions always have a tree structure
|
|
|
150 2006-11-19.txt:22:35:20: <SimonRC> You go up the tree, then down.
|
|
|
151 2006-11-19.txt:22:36:03: <SimonRC> Of course, it's nothing like a tree really, but the addresses *are* assigned so that you can abbreviate the routing table and still get very good results
|
|
|
152 2006-12-02.txt:02:09:19: <bsmntbombdood> Maelzel, who bade me pleasant weather the eyelids were it will be sure trader, I believed from tree stood a man whipped syllable!
|
|
|
153 2006-12-02.txt:22:28:07: * SimonRC finds some clever code to flatten a Scheme-style tree:
|
|
|
154 2006-12-10.txt:22:22:02: <calamari> SimonRC: yeah.. the hard part at least for my brain is building some kind of tree or such
|
|
|
155 2006-12-10.txt:23:53:46: <oerjan> one idea is to encode the label in binary and use a branching tree for the case statement
|
|
|
156 2006-12-20.txt:17:11:47: <bsmntbombdood> I think I'm goign to ski down my street later
|
|
|
157 2007-01-01.txt:20:38:37: <pikhq> There'd be no actual *tree* in such an FS.
|
|
|
158 2007-01-01.txt:21:59:06: <CakeProphet> fuck trees.
|
|
|
159 2007-01-01.txt:22:01:09: <ihope_> Why did he do from the trees? I don't know through it.
|
|
|
160 2007-01-01.txt:23:36:23: <ihope> CakeProphet: a compiler turns BF into something else, then runs it. An interpreter turns it into a list/tree/thing of instructions and runs through those.
|
|
|
161 2007-01-03.txt:20:58:05: <CakeProphet> So thinks like variable names, call stacks, evaluation stack, parse trees, and language syntax should all be expressable by data of some sort.
|
|
|
162 2007-01-03.txt:21:24:16: <SimonRC> once the forms are read it, there is compile time, which IIRC starts with macro-expansion, which allows you to pass parts of parse trees (s-expressions) through arbitrary functions, which it handy.
|
|
|
163 2007-01-11.txt:01:35:33: <oerjan> The Data.Map library uses binary trees.
|
|
|
164 2007-01-11.txt:01:46:23: <oerjan> or possibly pointers to binary trees, I guess.
|
|
|
165 2007-01-12.txt:01:52:41: <CakeProphet> "(" simply means accumulate another branch to the parse tree... ")" mean return to the last node... " and ' would start a string and symbol mode respectively.
|
|
|
166 2007-01-12.txt:02:11:38: <bsmntbombdood> I'm not sure what the parse tree should look like
|
|
|
167 2007-01-12.txt:02:37:12: <oerjan> And by the way, this is easiest in functional style: the result value of the function should be the parse tree of what that invocation has parsed.
|
|
|
168 2007-01-12.txt:03:11:29: <oerjan> You are missing a tree.append(buff) before the return.
|
|
|
169 2007-01-12.txt:05:45:42: <bsmntbombdood> It parses python into syntax trees
|
|
|
170 2007-01-12.txt:05:53:22: <bsmntbombdood> You can write python as syntax trees :)
|
|
|
171 2007-01-13.txt:23:34:24: <RodgerTheGreat> has anyone made a good tree implementation in BF?
|
|
|
172 2007-01-15.txt:23:13:16: <pikhq> Not counting my C backend, which I have yet to sync in with the rest of my tree.
|
|
|
173 2007-01-18.txt:01:26:24: <CakeProphet> I wonder how you would use a tree as a languages data structure.
|
|
|
174 2007-01-18.txt:01:27:10: <oklopol> you can have tree data structures as vars then
|
|
|
175 2007-01-18.txt:01:27:54: <CakeProphet> and trees.
|
|
|
176 2007-01-18.txt:01:28:36: <CakeProphet> you could take a lisp-ish approach and make the program a tree.
|
|
|
177 2007-01-18.txt:01:29:18: <oklopol> you could just code it as a tree, no ascii shit
|
|
|
178 2007-01-22.txt:00:26:29: <oklopol> the tree-parsing was not explained at all
|
|
|
179 2007-02-01.txt:22:18:48: <SimonRC> abstract syntax tree
|
|
|
180 2007-02-08.txt:01:23:26: <ihope_> You need a way to represent trees in C.
|
|
|
181 2007-02-08.txt:01:24:22: <bsmntbombdood> tree as in sexp?
|
|
|
182 2007-02-08.txt:01:30:43: <ihope_> That's a tree with either S or K at each leaf?
|
|
|
183 2007-02-08.txt:01:31:59: <bsmntbombdood> that's a tree with either S or K at each leaf
|
|
|
184 2007-02-11.txt:02:54:57: <SevenInchBread> since Lisp code is just like... a parse tree.
|
|
|
185 2007-02-11.txt:22:22:40: <bsmntbombdood> yacc should build a parse tree implicitly to give to you after parsing
|
|
|
186 2007-02-14.txt:18:46:21: <GregorR> oerjan.ooTree.reasonable = false;
|
|
|
187 2007-02-14.txt:18:48:07: <oerjan> Language.Haskell.ModuleTree /= ObjectOriented
|
|
|
188 2007-02-14.txt:21:05:15: <oklopol> i have one in c++ that does nice circular tree structures
|
|
|
189 2007-02-17.txt:02:18:54: <oerjan> And if you reduce the Ei expressions recursively to their head normal forms (or to V if they don't have any) then you get a tree structure which may sometimes be infinite.
|
|
|
190 2007-02-17.txt:02:22:47: <oerjan> Bõhm trees.
|
|
|
191 2007-02-20.txt:23:27:18: <SevenInchBread> It's basically a binary tree of arrays of characters (a tree of strings).
|
|
|
192 2007-02-22.txt:17:34:59: * oerjan thinks his data structure for implementing V's sum tree was moderately clever. :)
|
|
|
193 2007-02-22.txt:17:37:43: <ais523> You have a structure consisting of a binary tree and a linked list of binary trees?
|
|
|
194 2007-02-22.txt:17:38:51: <oerjan> well, i guess you could call it that. It's just a zipped binary tree.
|
|
|
195 2007-02-22.txt:17:39:54: <ais523> For Underload's superset language, Overload, I'm using a data structure which is effectively a doubly-linked binary tree
|
|
|
196 2007-02-22.txt:17:40:29: <SimonRC> ITYM "binary tree with upward links".
|
|
|
197 2007-02-22.txt:17:40:57: <ais523> because the trees are also infinite
|
|
|
198 2007-02-22.txt:17:46:14: <oklopol> oaky could be the name of a tree-based lang
|
|
|
199 2007-02-22.txt:17:46:59: <ais523> how does this tree-based language work, then?
|
|
|
200 2007-02-25.txt:02:27:40: <ihope> bsmntbombdood: fancy spelling of "tree", isn't it?
|
|
|
201 2007-02-25.txt:02:28:59: <oerjan> not quite. A trie is a special kind of tree, in which every key has a specific place in the tree, known at the outset.
|
|
|
202 2007-02-25.txt:22:07:42: <oerjan> basically, if there is only one leaf in a subtree, you save it directly.
|
|
|
203 2007-02-25.txt:22:07:53: <oerjan> at the top of that subtree.
|
|
|
204 2007-03-04.txt:00:35:49: <SimonRC> with clever sharing, a number could easily be a tree with NILs at the leaves
|
|
|
205 2007-03-04.txt:00:36:08: <SevenInchBread> so then concatenation of the trees would be like addition.
|
|
|
206 2007-03-12.txt:16:19:52: <oerjan> Trees.
|
|
|
207 2007-03-17.txt:01:28:16: <oerjan> I found a downloadable Data.FingerTree module in which you can select any Monoid as your size measure.
|
|
|
208 2007-03-17.txt:01:54:52: <bsmntbombdood> FingerTree!
|
|
|
209 2007-03-19.txt:00:10:41: <oklopol> even though i was thinking about tree cones
|
|
|
210 2007-03-20.txt:18:14:34: <oklopol> well, the string could hang from a tree, and trees can grow
|
|
|
211 2007-03-20.txt:18:16:40: <ais523> apple tree -> apples -> rotten apples -> seeds -> more apple trees (unboundedly); apple tree -> wood -> box (when it stops producing apples); so all you need is the string and an infinitely large orchard, as you can get the apple tree from the rotten apples
|
|
|
212 2007-03-20.txt:18:21:34: <RodgerTheGreat> perhaps all that's necessary is using the life cycle of the trees for computation
|
|
|
213 2007-03-20.txt:18:22:19: <RodgerTheGreat> the survival and reproduction of trees as they compete for space is your computational system
|
|
|
214 2007-03-20.txt:18:22:41: <ais523> I'd like to see an apple-tree implementation of Life. It would be kind of appropriate.
|
|
|
215 2007-03-20.txt:18:23:05: <jix> hmm apple trees should be renamed to iTrees
|
|
|
216 2007-03-20.txt:18:23:40: <RodgerTheGreat> oerjan: the string could be used, but just trees in dirt seems more elegant
|
|
|
217 2007-03-22.txt:01:29:18: <SevenInchBread> hmmm... representing files as linked lists allows you to create infinite files - and tree structures.
|
|
|
218 2007-03-22.txt:11:41:01: <SimonRC> so you have a netwok rather than a tree
|
|
|
219 2007-03-22.txt:11:48:46: <SimonRC> a sort of cross between a big directory tree and a collection of DB tables
|
|
|
220 2007-03-22.txt:11:52:11: <SimonRC> BF programs are basically trees of strings of "<>+-,.", right?
|
|
|
221 2007-03-22.txt:22:57:30: <SevenInchBread> hmmm... I think it makes more sense to represent concatenations as trees... instead of just returning the combined result.
|
|
|
222 2007-03-25.txt:21:57:02: <SevenInchBread> the "parens" of the parse tree. ;)
|
|
|
223 2007-03-25.txt:22:53:15: <oklopol> i'd not save the name of a var anywhere even if just making a parse tree
|
|
|
224 2007-03-26.txt:23:19:36: <SevenInchBread> eh... I'll continue Sprout another day. I want to do like a "structured self-modification". Where you can give bits of the parse tree a label and then say "replace everything at x with SomeCode"
|
|
|
225 2007-03-26.txt:23:42:24: <oerjan> The files are oerjan.nvg.org/esoteric/Dupdog.hs and oerjan.nvg.org/esoteric/FingerTree.hs (third party module)
|
|
|
226 2007-03-27.txt:16:16:13: <Figs> you'd have to set up the entire program in a tree
|
|
|
227 2007-03-28.txt:18:17:49: <Figs> Tree = a < ((b<(d<i+j+k))+e);
|
|
|
228 2007-03-28.txt:18:19:26: <Figs> print(Tree);
|
|
|
229 2007-03-28.txt:18:20:34: <Figs> Tree = a < (((b<(d<i+j+k))+e)+(c<f+g+h));
|
|
|
230 2007-03-28.txt:18:21:43: <ais523> you should have redefined the whole nature of trees just so you could get away with using < and >
|
|
|
231 2007-03-28.txt:18:22:40: <Figs> Tree = a < (((b<(d<i+j+k))+e)+(c<f+g+h)); //Working C++ :D
|
|
|
232 2007-03-28.txt:18:25:44: <lament> Figs: not sure what kind of "actual project" needs hardcoded definition of trees.
|
|
|
233 2007-03-28.txt:18:26:35: <ais523> (the tree you wrote above in HOMESPRING notation)
|
|
|
234 2007-03-28.txt:18:26:58: <Figs> and interprets the tokens and reassembles a sequence (tree structure) by parsing it
|
|
|
235 2007-03-28.txt:18:29:07: * Figs can think of some weird uses for tree-manip. functions
|
|
|
236 2007-03-28.txt:18:29:34: <Figs> functions that clone trees and graft the clones on as new branches...
|
|
|
237 2007-03-28.txt:18:31:41: <ais523> some languages are better for trees than others
|
|
|
238 2007-03-28.txt:18:31:54: <ais523> the tree is the easiest data structure to understand in both Unlambda and Underload
|
|
|
239 2007-03-28.txt:18:32:18: <Figs> I think the tree is most certainly one of the harder to understand ds's when you try to use it in C++
|
|
|
240 2007-03-28.txt:18:33:26: <lament> a tree is almost the same as a linked list
|
|
|
241 2007-03-28.txt:18:35:13: * oerjan is reading the logs, and doesn't understand why Figs said bruteforcing the 4444 problem by setting up trees is hard. Figs must not know Haskell. :)
|
|
|
242 2007-03-30.txt:00:51:25: <oklopol> you don't know lazy. it took ½ an hour for me to leave for the shop across the street because i was too lazy to put on shoes
|
|
|
243 2007-04-01.txt:04:34:59: <CakeProphet> You can't say "hey this is a tree" or "hey this is a table"... without forcing every program that reads it to do some parsing.
|
|
|
244 2007-04-01.txt:04:36:16: <Figs> have you guys tried writing a general purpose tree?
|
|
|
245 2007-04-01.txt:04:36:57: <Figs> like, a C++ style library for tree structures like vectors, lists, maps, etc
|
|
|
246 2007-04-01.txt:04:37:32: <CakeProphet> well.... Lisp is pretty well-suited for trees... it uses linked lists internally.
|
|
|
247 2007-04-01.txt:04:38:00: <CakeProphet> or you could get all hyper-OO and make a tree object... if you're bat-fucking insane.
|
|
|
248 2007-04-01.txt:05:54:04: <CakeProphet> http://deadbeefbabe.org/paste/4188 <-- a very simple Tree like structure in Python
|
|
|
249 2007-04-01.txt:05:56:04: <Figs> class Tree(list):
|
|
|
250 2007-04-01.txt:05:56:12: <Figs> I assume you're declaring the clas Tree
|
|
|
251 2007-04-02.txt:01:49:02: <CakeProphet> except this one uses a decision tree to find the shorted possible way to do it.
|
|
|
252 2007-04-02.txt:22:43:50: <CakeProphet_> the whole "everything is an object" notion is infinitely recursive... you have objects consisting of objects.... the tree needs leaves at some point.
|
|
|
253 2007-04-08.txt:02:45:46: <CakeProphet> hehehehe... it's like a tree
|
|
|
254 2007-04-09.txt:00:20:19: <ihope> Having processes arranged in trees is... well, what's the reason behind that?
|
|
|
255 2007-04-09.txt:00:28:40: <ihope> So is there really any reason to put services in a tree like that/
|
|
|
256 2007-04-09.txt:03:25:59: <Pikhq> I'm using buildroot to create the initial root tree. . .
|
|
|
257 2007-04-10.txt:01:28:11: <Sukoshi> I would hope so, because you can make a tree based on parameters.
|
|
|
258 2007-04-10.txt:01:49:26: <bsmntbombdood> I suppose an ordered binary tree would work
|
|
|
259 2007-04-10.txt:01:55:30: <oerjan> making the tree balanced immediately.
|
|
|
260 2007-04-10.txt:01:58:42: <oerjan> recursively: make 2^n-1 first elements into one subtree, then read middle, then 2^n-1 next into another, then put together.
|
|
|
261 2007-04-10.txt:23:19:18: <Sukoshi> bsmntbombdood: Classes are just structs with type information. Generic methods are determined and then less-specific behavior is inlined if the function is ``continues'', and these are all kept either in a virtual method table or a tree that matches based on parameter.
|
|
|
262 2007-04-11.txt:00:48:46: <Sukoshi> Methods can *only* be executed linearly up the specific tree. No cast-avoiding.
|
|
|
263 2007-04-11.txt:01:51:42: <GregorR> I always forget which term is used to mean it falls lower on the tree :P
|
|
|
264 2007-04-17.txt:02:06:19: <SevenInchBread> will usually be close together in a directory tree.... usually. I have no empircal evidence to back that up.
|
|
|
265 2007-04-22.txt:00:47:15: <oerjan> http://oerjan.nvg.org/esoteric/Dupdog.hs + FingerTree.hs. You can in theory use it if you can put the right functions together...
|
|
|
266 2007-04-22.txt:00:54:45: <oerjan> by using the FingerTree module which implements lazily concatenated sequences
|
|
|
267 2007-04-22.txt:00:59:50: <oerjan> i suppose you could do such a structure with some simpler kind of tree, you need duplication, push and pop at both ends
|
|
|
268 2007-04-22.txt:01:14:04: <SevenInchBread> oerjan, hmm... reverse lookup is hard to handle with tree concatenation
|
|
|
269 2007-04-22.txt:01:16:33: <SevenInchBread> >.> but with a tree you need to recurse the entire tree to get the very last character
|
|
|
270 2007-04-22.txt:01:17:14: <oerjan> you must recurse in any case unless you use the very clever FingerTree stuff
|
|
|
271 2007-04-22.txt:01:17:42: <oerjan> i believe that works by rebalancing the tree so the ends are always shallow
|
|
|
272 2007-04-22.txt:01:19:01: <oerjan> which is the same as for lookup in a naive tree
|
|
|
273 2007-04-22.txt:01:31:08: <SevenInchBread> oerjan, I think the main rationale for using trees in memory.
|
|
|
274 2007-04-22.txt:01:32:39: <SevenInchBread> without using trees at all
|
|
|
275 2007-04-22.txt:02:31:21: <oerjan> essentially i think the tree will creep back in
|
|
|
276 2007-04-22.txt:02:40:56: <oerjan> yes, you want to save indexes instead of trees.
|
|
|
277 2007-04-28.txt:06:13:03: <oerjan> Haskell uses finger trees.
|
|
|
278 2007-05-15.txt:15:58:50: <oerjan> interesting that irc has so many netsplits because it is tree structured without cycles, and somehow they cannot fix that fundamental flaw
|
|
|
279 2007-05-15.txt:16:04:08: <SimonRC> routing in a non-tree is a PITA
|
|
|
280 2007-05-18.txt:02:43:20: <SimonRC> then, you mutate the program by fiddling with the tree
|
|
|
281 2007-05-18.txt:02:44:51: <SimonRC> Also, tree-surgery makes for a good way to mate programs together.
|
|
|
282 2007-05-18.txt:02:46:08: <SimonRC> The main one being that the explicit tree structures help you avoid syntax errors.
|
|
|
283 2007-05-18.txt:08:44:25: <GregorR> My attempt with something more similar to SimonRC's suggested tree isn't going well :P
|
|
|
284 2007-05-27.txt:03:17:40: <SimonRC> pointer-free trees might not be to bad...
|
|
|
285 2007-05-27.txt:03:18:40: <SimonRC> tree = [A=label][B=left subtree][C=right subtree][length of ABC]
|
|
|
286 2007-05-27.txt:03:19:59: <SimonRC> an empty tree would have a special label field.
|
|
|
287 2007-05-27.txt:03:20:42: <SimonRC> i.e. look at the right subtree
|
|
|
288 2007-05-27.txt:03:26:43: <bsmntbombdood> it makes more sense to have length at the begining for a tree
|
|
|
289 2007-05-27.txt:03:28:54: <bsmntbombdood> you can't put anything in the right subtree untill you find how long the left one is
|
|
|
290 2007-05-27.txt:03:31:37: <bsmntbombdood> ...and so on in the right subtree
|
|
|
291 2007-05-29.txt:22:19:42: <oklopol> if you have a way to make bnf'ish regexes, basically tree-rewriting
|
|
|
292 2007-05-31.txt:05:43:01: <bsmntbombdood> hmm, by representing strings as trees you get constant time concatenation and O(log n) time indexing
|
|
|
293 2007-06-01.txt:02:34:49: <oerjan> <bsmntbombdood> hmm, by representing strings as trees you get constant time concatenation and O(log n) time indexing
|
|
|
294 2007-06-01.txt:02:35:32: <Pikhq> But by representing strings as *arrays* of trees of lists, you get to be *really* confusing!
|
|
|
295 2007-06-01.txt:04:37:08: <oerjan> the paradox being that most people say they wouldn't participate for any price, yet most take greater risks every day just by crossing the street
|
|
|
296 2007-06-01.txt:04:37:44: <bsmntbombdood> you could die by crossing the street
|
|
|
297 2007-06-04.txt:17:57:51: * CakeProphet pauses as he traverses his decision tree.
|
|
|
298 2007-06-04.txt:17:58:00: <lament> tree? more like a bush!
|
|
|
299 2007-06-04.txt:18:07:36: <CakeProphet> my decision tree does not account for sarcasm
|
|
|
300 2007-06-04.txt:18:33:34: <CakeProphet> MY DECISION TREE... PREDICTED THIS.
|
|
|
301 [too many lines; stopping]
|
